diff options
Diffstat (limited to 'devtools/client/memory/test/unit')
52 files changed, 3571 insertions, 0 deletions
diff --git a/devtools/client/memory/test/unit/.eslintrc.js b/devtools/client/memory/test/unit/.eslintrc.js new file mode 100644 index 000000000..aec096a0f --- /dev/null +++ b/devtools/client/memory/test/unit/.eslintrc.js @@ -0,0 +1,6 @@ +"use strict"; + +module.exports = { + // Extend from the shared list of defined globals for mochitests. + "extends": "../../../../.eslintrc.xpcshell.js" +}; diff --git a/devtools/client/memory/test/unit/head.js b/devtools/client/memory/test/unit/head.js new file mode 100644 index 000000000..f1335dc3d --- /dev/null +++ b/devtools/client/memory/test/unit/head.js @@ -0,0 +1,128 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +var { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components; +var { console } = Cu.import("resource://gre/modules/Console.jsm", {}); +var { require } = Cu.import("resource://devtools/shared/Loader.jsm", {}); + +var Services = require("Services"); +var DevToolsUtils = require("devtools/shared/DevToolsUtils"); +var flags = require("devtools/shared/flags"); +flags.testing = true; +flags.wantLogging = true; +flags.wantVerbose = false; + +var { OS } = require("resource://gre/modules/osfile.jsm"); +var { FileUtils } = require("resource://gre/modules/FileUtils.jsm"); +var { TargetFactory } = require("devtools/client/framework/target"); +var promise = require("promise"); +var defer = require("devtools/shared/defer"); +var { Task } = require("devtools/shared/task"); +var { expectState } = require("devtools/server/actors/common"); +var HeapSnapshotFileUtils = require("devtools/shared/heapsnapshot/HeapSnapshotFileUtils"); +var HeapAnalysesClient = require("devtools/shared/heapsnapshot/HeapAnalysesClient"); +var { addDebuggerToGlobal } = require("resource://gre/modules/jsdebugger.jsm"); +var Store = require("devtools/client/memory/store"); +var { L10N } = require("devtools/client/memory/utils"); +var SYSTEM_PRINCIPAL = Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal); + +var EXPECTED_DTU_ASSERT_FAILURE_COUNT = 0; + +do_register_cleanup(function () { + equal(DevToolsUtils.assertionFailureCount, EXPECTED_DTU_ASSERT_FAILURE_COUNT, + "Should have had the expected number of DevToolsUtils.assert() failures."); +}); + +function dumpn(msg) { + dump(`MEMORY-TEST: ${msg}\n`); +} + +function initDebugger() { + let global = new Cu.Sandbox(SYSTEM_PRINCIPAL, { freshZone: true }); + addDebuggerToGlobal(global); + return new global.Debugger(); +} + +function StubbedMemoryFront() { + this.state = "detached"; + this.recordingAllocations = false; + this.dbg = initDebugger(); +} + +StubbedMemoryFront.prototype.attach = Task.async(function* () { + this.state = "attached"; +}); + +StubbedMemoryFront.prototype.detach = Task.async(function* () { + this.state = "detached"; +}); + +StubbedMemoryFront.prototype.saveHeapSnapshot = expectState("attached", Task.async(function* () { + return ThreadSafeChromeUtils.saveHeapSnapshot({ runtime: true }); +}), "saveHeapSnapshot"); + +StubbedMemoryFront.prototype.startRecordingAllocations = expectState("attached", Task.async(function* () { + this.recordingAllocations = true; +})); + +StubbedMemoryFront.prototype.stopRecordingAllocations = expectState("attached", Task.async(function* () { + this.recordingAllocations = false; +})); + +function waitUntilSnapshotState(store, expected) { + let predicate = () => { + let snapshots = store.getState().snapshots; + do_print(snapshots.map(x => x.state)); + return snapshots.length === expected.length && + expected.every((state, i) => state === "*" || snapshots[i].state === state); + }; + do_print(`Waiting for snapshots to be of state: ${expected}`); + return waitUntilState(store, predicate); +} + +function findReportLeafIndex(node, name = null) { + if (node.reportLeafIndex && (!name || node.name === name)) { + return node.reportLeafIndex; + } + + if (node.children) { + for (let child of node.children) { + const found = findReportLeafIndex(child); + if (found) { + return found; + } + } + } + + return null; +} + +function waitUntilCensusState(store, getCensus, expected) { + let predicate = () => { + let snapshots = store.getState().snapshots; + + do_print("Current census state:" + + snapshots.map(x => getCensus(x) ? getCensus(x).state : null)); + + return snapshots.length === expected.length && + expected.every((state, i) => { + let census = getCensus(snapshots[i]); + return (state === "*") || + (!census && !state) || + (census && census.state === state); + }); + }; + do_print(`Waiting for snapshots' censuses to be of state: ${expected}`); + return waitUntilState(store, predicate); +} + +function* createTempFile() { + let file = FileUtils.getFile("TmpD", ["tmp.fxsnapshot"]); + file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE); + let destPath = file.path; + let stat = yield OS.File.stat(destPath); + ok(stat.size === 0, "new file is 0 bytes at start"); + return destPath; +} diff --git a/devtools/client/memory/test/unit/test_action-clear-snapshots_01.js b/devtools/client/memory/test/unit/test_action-clear-snapshots_01.js new file mode 100644 index 000000000..a4e611e84 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-clear-snapshots_01.js @@ -0,0 +1,38 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test clearSnapshots deletes snapshots with READ censuses + +let { takeSnapshotAndCensus, clearSnapshots } = require("devtools/client/memory/actions/snapshot"); +let { snapshotState: states, actions } = require("devtools/client/memory/constants"); +const { treeMapState } = require("devtools/client/memory/constants"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.treeMap, [treeMapState.SAVED]); + ok(true, "snapshot created"); + + ok(true, "dispatch clearSnapshots action"); + let deleteEvents = Promise.all([ + waitUntilAction(store, actions.DELETE_SNAPSHOTS_START), + waitUntilAction(store, actions.DELETE_SNAPSHOTS_END) + ]); + dispatch(clearSnapshots(heapWorker)); + yield deleteEvents; + ok(true, "received delete snapshots events"); + + equal(getState().snapshots.length, 0, "no snapshot remaining"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-clear-snapshots_02.js b/devtools/client/memory/test/unit/test_action-clear-snapshots_02.js new file mode 100644 index 000000000..bb8c118cd --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-clear-snapshots_02.js @@ -0,0 +1,47 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test clearSnapshots preserves snapshots with state != READ or ERROR + +let { takeSnapshotAndCensus, clearSnapshots, takeSnapshot } = require("devtools/client/memory/actions/snapshot"); +let { snapshotState: states, treeMapState, actions } = require("devtools/client/memory/constants"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + ok(true, "create a snapshot with a census in SAVED state"); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + ok(true, "create a snapshot in SAVED state"); + dispatch(takeSnapshot(front)); + yield waitUntilSnapshotState(store, [states.SAVED, states.SAVED]); + yield waitUntilCensusState(store, snapshot => snapshot.treeMap, + [treeMapState.SAVED, null]); + ok(true, "snapshots created with expected states"); + + ok(true, "dispatch clearSnapshots action"); + let deleteEvents = Promise.all([ + waitUntilAction(store, actions.DELETE_SNAPSHOTS_START), + waitUntilAction(store, actions.DELETE_SNAPSHOTS_END) + ]); + dispatch(clearSnapshots(heapWorker)); + yield deleteEvents; + ok(true, "received delete snapshots events"); + + equal(getState().snapshots.length, 1, "one snapshot remaining"); + let remainingSnapshot = getState().snapshots[0]; + equal(remainingSnapshot.treeMap, undefined, + "remaining snapshot doesn't have a treeMap property"); + equal(remainingSnapshot.census, undefined, + "remaining snapshot doesn't have a census property"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-clear-snapshots_03.js b/devtools/client/memory/test/unit/test_action-clear-snapshots_03.js new file mode 100644 index 000000000..ae888f858 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-clear-snapshots_03.js @@ -0,0 +1,46 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test clearSnapshots deletes snapshots with state ERROR + +let { takeSnapshotAndCensus, clearSnapshots } = require("devtools/client/memory/actions/snapshot"); +let { snapshotState: states, treeMapState, actions } = require("devtools/client/memory/constants"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + ok(true, "create a snapshot with a treeMap"); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilSnapshotState(store, [states.SAVED]); + ok(true, "snapshot created with a SAVED state"); + yield waitUntilCensusState(store, snapshot => snapshot.treeMap, + [treeMapState.SAVED]); + ok(true, "treeMap created with a SAVED state"); + + ok(true, "set snapshot state to error"); + let id = getState().snapshots[0].id; + dispatch({ type: actions.SNAPSHOT_ERROR, id, error: new Error("_") }); + yield waitUntilSnapshotState(store, [states.ERROR]); + ok(true, "snapshot set to error state"); + + ok(true, "dispatch clearSnapshots action"); + let deleteEvents = Promise.all([ + waitUntilAction(store, actions.DELETE_SNAPSHOTS_START), + waitUntilAction(store, actions.DELETE_SNAPSHOTS_END) + ]); + dispatch(clearSnapshots(heapWorker)); + yield deleteEvents; + ok(true, "received delete snapshots events"); + equal(getState().snapshots.length, 0, "error snapshot deleted"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-clear-snapshots_04.js b/devtools/client/memory/test/unit/test_action-clear-snapshots_04.js new file mode 100644 index 000000000..f5b316b1a --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-clear-snapshots_04.js @@ -0,0 +1,49 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test clearSnapshots deletes several snapshots + +let { takeSnapshotAndCensus, clearSnapshots } = require("devtools/client/memory/actions/snapshot"); +let { snapshotState: states, actions, treeMapState } = require("devtools/client/memory/constants"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + ok(true, "create 3 snapshots with a saved census"); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, snapshot => snapshot.treeMap, + [treeMapState.SAVED, treeMapState.SAVED, + treeMapState.SAVED]); + ok(true, "snapshots created with a saved census"); + + ok(true, "set first snapshot state to error"); + let id = getState().snapshots[0].id; + dispatch({ type: actions.SNAPSHOT_ERROR, id, error: new Error("_") }); + yield waitUntilSnapshotState(store, + [states.ERROR, states.READ, states.READ]); + ok(true, "first snapshot set to error state"); + + ok(true, "dispatch clearSnapshots action"); + let deleteEvents = Promise.all([ + waitUntilAction(store, actions.DELETE_SNAPSHOTS_START), + waitUntilAction(store, actions.DELETE_SNAPSHOTS_END) + ]); + dispatch(clearSnapshots(heapWorker)); + yield deleteEvents; + ok(true, "received delete snapshots events"); + + equal(getState().snapshots.length, 0, "no snapshot remaining"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-clear-snapshots_05.js b/devtools/client/memory/test/unit/test_action-clear-snapshots_05.js new file mode 100644 index 000000000..9b889b3a4 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-clear-snapshots_05.js @@ -0,0 +1,47 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test clearSnapshots deletes several snapshots + +let { takeSnapshotAndCensus, clearSnapshots } = require("devtools/client/memory/actions/snapshot"); +let { snapshotState: states, actions, treeMapState } = require("devtools/client/memory/constants"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + ok(true, "create 2 snapshots with a saved census"); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + ok(true, "snapshots created with a saved census"); + yield waitUntilCensusState(store, snapshot => snapshot.treeMap, + [treeMapState.SAVED, treeMapState.SAVED]); + + let errorHeapWorker = { + deleteHeapSnapshot: function () { + return Promise.reject("_"); + } + }; + + ok(true, "dispatch clearSnapshots action"); + let deleteEvents = Promise.all([ + waitUntilAction(store, actions.DELETE_SNAPSHOTS_START), + waitUntilAction(store, actions.DELETE_SNAPSHOTS_END), + waitUntilAction(store, actions.SNAPSHOT_ERROR), + waitUntilAction(store, actions.SNAPSHOT_ERROR), + ]); + dispatch(clearSnapshots(errorHeapWorker)); + yield deleteEvents; + ok(true, "received delete snapshots and snapshot error events"); + equal(getState().snapshots.length, 0, "no snapshot remaining"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-clear-snapshots_06.js b/devtools/client/memory/test/unit/test_action-clear-snapshots_06.js new file mode 100644 index 000000000..1ee32bb12 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-clear-snapshots_06.js @@ -0,0 +1,65 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +// Test that clearSnapshots disables diffing when deleting snapshots + +const { + takeSnapshotAndCensus, + clearSnapshots +} = require("devtools/client/memory/actions/snapshot"); +const { + snapshotState: states, + actions, + treeMapState +} = require("devtools/client/memory/constants"); +const { + toggleDiffing, + selectSnapshotForDiffingAndRefresh +} = require("devtools/client/memory/actions/diffing"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + ok(true, "create 2 snapshots with a saved census"); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, snapshot => snapshot.treeMap, + [treeMapState.SAVED, treeMapState.SAVED]); + ok(true, "snapshots created with a saved census"); + + dispatch(toggleDiffing()); + dispatch(selectSnapshotForDiffingAndRefresh(heapWorker, + getState().snapshots[0])); + dispatch(selectSnapshotForDiffingAndRefresh(heapWorker, + getState().snapshots[1])); + + ok(getState().diffing, "We should be in diffing view"); + + yield waitUntilAction(store, actions.TAKE_CENSUS_DIFF_END); + ok(true, "Received TAKE_CENSUS_DIFF_END action"); + + ok(true, "Dispatch clearSnapshots action"); + let deleteEvents = Promise.all([ + waitUntilAction(store, actions.DELETE_SNAPSHOTS_START), + waitUntilAction(store, actions.DELETE_SNAPSHOTS_END) + ]); + dispatch(clearSnapshots(heapWorker)); + yield deleteEvents; + ok(true, "received delete snapshots events"); + + ok(getState().snapshots.length === 0, "Snapshots array should be empty"); + ok(!getState().diffing, "We should no longer be diffing"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-export-snapshot.js b/devtools/client/memory/test/unit/test_action-export-snapshot.js new file mode 100644 index 000000000..0582abbf0 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-export-snapshot.js @@ -0,0 +1,39 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test exporting a snapshot to a user specified location on disk. + +let { exportSnapshot } = require("devtools/client/memory/actions/io"); +let { takeSnapshotAndCensus } = require("devtools/client/memory/actions/snapshot"); +let { snapshotState: states, actions, treeMapState } = require("devtools/client/memory/constants"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + let destPath = yield createTempFile(); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, snapshot => snapshot.treeMap, + [treeMapState.SAVED]); + + let exportEvents = Promise.all([ + waitUntilAction(store, actions.EXPORT_SNAPSHOT_START), + waitUntilAction(store, actions.EXPORT_SNAPSHOT_END) + ]); + dispatch(exportSnapshot(getState().snapshots[0], destPath)); + yield exportEvents; + + stat = yield OS.File.stat(destPath); + do_print(stat.size); + ok(stat.size > 0, "destination file is more than 0 bytes"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-filter-01.js b/devtools/client/memory/test/unit/test_action-filter-01.js new file mode 100644 index 000000000..e0894606d --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-filter-01.js @@ -0,0 +1,23 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test setting the filter string. + +let { setFilterString } = require("devtools/client/memory/actions/filter"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let store = Store(); + const { getState, dispatch } = store; + + equal(getState().filter, null, "no filter by default"); + + dispatch(setFilterString("my filter")); + equal(getState().filter, "my filter", "now we have the expected filter"); + + dispatch(setFilterString("")); + equal(getState().filter, null, "no filter again"); +}); diff --git a/devtools/client/memory/test/unit/test_action-filter-02.js b/devtools/client/memory/test/unit/test_action-filter-02.js new file mode 100644 index 000000000..31d777704 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-filter-02.js @@ -0,0 +1,74 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test that changing filter state properly refreshes the selected census. + +let { snapshotState: states, viewState, censusState } = require("devtools/client/memory/constants"); +let { setFilterStringAndRefresh } = require("devtools/client/memory/actions/filter"); +let { takeSnapshotAndCensus, selectSnapshotAndRefresh } = require("devtools/client/memory/actions/snapshot"); +let { setCensusDisplay } = require("devtools/client/memory/actions/census-display"); +let { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + equal(getState().filter, null, "no filter by default"); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + ok(true, "saved 3 snapshots and took a census of each of them"); + + dispatch(setFilterStringAndRefresh("str", heapWorker)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVED, + censusState.SAVING]); + ok(true, "setting filter string should recompute the selected snapshot's census"); + + equal(getState().filter, "str", "now inverted"); + + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + + equal(getState().snapshots[0].census.filter, null); + equal(getState().snapshots[1].census.filter, null); + equal(getState().snapshots[2].census.filter, "str"); + + dispatch(selectSnapshotAndRefresh(heapWorker, getState().snapshots[1].id)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVING, + censusState.SAVED]); + ok(true, "selecting non-inverted census should trigger a recompute"); + + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + + equal(getState().snapshots[0].census.filter, null); + equal(getState().snapshots[1].census.filter, "str"); + equal(getState().snapshots[2].census.filter, "str"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-filter-03.js b/devtools/client/memory/test/unit/test_action-filter-03.js new file mode 100644 index 000000000..4d46d5361 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-filter-03.js @@ -0,0 +1,52 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that changing filter state in the middle of taking a snapshot results in +// the properly fitered census. + +let { snapshotState: states, censusState, viewState } = require("devtools/client/memory/constants"); +let { setFilterString, setFilterStringAndRefresh } = require("devtools/client/memory/actions/filter"); +let { takeSnapshotAndCensus } = require("devtools/client/memory/actions/snapshot"); +let { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilSnapshotState(store, [states.SAVING]); + + dispatch(setFilterString("str")); + + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED]); + equal(getState().filter, "str", + "should want filtered trees"); + equal(getState().snapshots[0].census.filter, "str", + "snapshot-we-were-in-the-middle-of-saving's census should be filtered"); + + dispatch(setFilterStringAndRefresh("", heapWorker)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVING]); + ok(true, "changing filter string retriggers census"); + ok(!getState().filter, "no longer filtering"); + + dispatch(setFilterString("obj")); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED]); + equal(getState().filter, "obj", "filtering for obj now"); + equal(getState().snapshots[0].census.filter, "obj", + "census-we-were-in-the-middle-of-recomputing should be filtered again"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-import-snapshot-and-census.js b/devtools/client/memory/test/unit/test_action-import-snapshot-and-census.js new file mode 100644 index 000000000..a7e1d366a --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-import-snapshot-and-census.js @@ -0,0 +1,98 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +/** + * Tests the task creator `importSnapshotAndCensus()` for the whole flow of + * importing a snapshot, and its sub-actions. + */ + +let { actions, snapshotState: states, treeMapState } = require("devtools/client/memory/constants"); +let { exportSnapshot, importSnapshotAndCensus } = require("devtools/client/memory/actions/io"); +let { takeSnapshotAndCensus } = require("devtools/client/memory/actions/snapshot"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { subscribe, dispatch, getState } = store; + + let destPath = yield createTempFile(); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.treeMap, [treeMapState.SAVED]); + + let exportEvents = Promise.all([ + waitUntilAction(store, actions.EXPORT_SNAPSHOT_START), + waitUntilAction(store, actions.EXPORT_SNAPSHOT_END) + ]); + dispatch(exportSnapshot(getState().snapshots[0], destPath)); + yield exportEvents; + + // Now import our freshly exported snapshot + let snapshotI = 0; + let censusI = 0; + let snapshotStates = ["IMPORTING", "READING", "READ"]; + let censusStates = ["SAVING", "SAVED"]; + let expectStates = () => { + let snapshot = getState().snapshots[1]; + if (!snapshot) { + return; + } + if (snapshotI < snapshotStates.length) { + let isCorrectState = snapshot.state === states[snapshotStates[snapshotI]]; + if (isCorrectState) { + ok(true, `Found expected snapshot state ${snapshotStates[snapshotI]}`); + snapshotI++; + } + } + if (snapshot.treeMap && censusI < censusStates.length) { + if (snapshot.treeMap.state === treeMapState[censusStates[censusI]]) { + ok(true, `Found expected census state ${censusStates[censusI]}`); + censusI++; + } + } + }; + + let unsubscribe = subscribe(expectStates); + dispatch(importSnapshotAndCensus(heapWorker, destPath)); + + yield waitUntilState(store, () => { return snapshotI === snapshotStates.length && + censusI === censusStates.length; }); + unsubscribe(); + equal(snapshotI, snapshotStates.length, "importSnapshotAndCensus() produces the correct sequence of states in a snapshot"); + equal(getState().snapshots[1].state, states.READ, "imported snapshot is in READ state"); + equal(censusI, censusStates.length, "importSnapshotAndCensus() produces the correct sequence of states in a census"); + equal(getState().snapshots[1].treeMap.state, treeMapState.SAVED, "imported snapshot is in READ state"); + ok(getState().snapshots[1].selected, "imported snapshot is selected"); + + // Check snapshot data + let snapshot1 = getState().snapshots[0]; + let snapshot2 = getState().snapshots[1]; + + equal(snapshot1.treeMap.display, snapshot2.treeMap.display, + "imported snapshot has correct display"); + + // Clone the census data so we can destructively remove the ID/parents to compare + // equal census data + let census1 = stripUnique(JSON.parse(JSON.stringify(snapshot1.treeMap.report))); + let census2 = stripUnique(JSON.parse(JSON.stringify(snapshot2.treeMap.report))); + + equal(JSON.stringify(census1), JSON.stringify(census2), "Imported snapshot has correct census"); + + function stripUnique(obj) { + let children = obj.children || []; + for (let child of children) { + delete child.id; + delete child.parent; + stripUnique(child); + } + delete obj.id; + delete obj.parent; + return obj; + } +}); diff --git a/devtools/client/memory/test/unit/test_action-import-snapshot-dominator-tree.js b/devtools/client/memory/test/unit/test_action-import-snapshot-dominator-tree.js new file mode 100644 index 000000000..868f22ccf --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-import-snapshot-dominator-tree.js @@ -0,0 +1,84 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +/** + * Tests `importSnapshotAndCensus()` when importing snapshots from the dominator + * tree view. The snapshot is expected to be loaded and its dominator tree + * should be computed. + */ + +let { snapshotState, dominatorTreeState, viewState, treeMapState } = + require("devtools/client/memory/constants"); +let { importSnapshotAndCensus } = require("devtools/client/memory/actions/io"); +let { changeViewAndRefresh } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { subscribe, dispatch, getState } = store; + + dispatch(changeViewAndRefresh(viewState.DOMINATOR_TREE, heapWorker)); + equal(getState().view.state, viewState.DOMINATOR_TREE, + "We should now be in the DOMINATOR_TREE view"); + + let i = 0; + let expected = [ + "IMPORTING", + "READING", + "READ", + "treeMap:SAVING", + "treeMap:SAVED", + "dominatorTree:COMPUTING", + "dominatorTree:FETCHING", + "dominatorTree:LOADED", + ]; + let expectStates = () => { + let snapshot = getState().snapshots[0]; + if (snapshot && hasExpectedState(snapshot, expected[i])) { + ok(true, `Found expected state ${expected[i]}`); + i++; + } + }; + + let unsubscribe = subscribe(expectStates); + const snapshotPath = yield front.saveHeapSnapshot(); + dispatch(importSnapshotAndCensus(heapWorker, snapshotPath)); + + yield waitUntilState(store, () => i === expected.length); + unsubscribe(); + equal(i, expected.length, "importSnapshotAndCensus() produces the correct " + + "sequence of states in a snapshot"); + equal(getState().snapshots[0].dominatorTree.state, dominatorTreeState.LOADED, + "imported snapshot's dominator tree is in LOADED state"); + ok(getState().snapshots[0].selected, "imported snapshot is selected"); +}); + +/** + * Check that the provided snapshot is in the expected state. The expected state + * is a snapshotState by default. If the expected state is prefixed by + * dominatorTree, a dominatorTree is expected on the provided snapshot, in the + * corresponding state from dominatorTreeState. + */ +function hasExpectedState(snapshot, expectedState) { + let isDominatorState = expectedState.indexOf("dominatorTree:") === 0; + if (isDominatorState) { + let state = dominatorTreeState[expectedState.replace("dominatorTree:", "")]; + return snapshot.dominatorTree && snapshot.dominatorTree.state === state; + } + + let isTreeMapState = expectedState.indexOf("treeMap:") === 0; + if (isTreeMapState) { + let state = treeMapState[expectedState.replace("treeMap:", "")]; + return snapshot.treeMap && snapshot.treeMap.state === state; + } + + let state = snapshotState[expectedState]; + return snapshot.state === state; +} diff --git a/devtools/client/memory/test/unit/test_action-select-snapshot.js b/devtools/client/memory/test/unit/test_action-select-snapshot.js new file mode 100644 index 000000000..2329ab2fa --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-select-snapshot.js @@ -0,0 +1,37 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * Tests the reducer responding to the action `selectSnapshot(snapshot)` + */ + +let actions = require("devtools/client/memory/actions/snapshot"); +let { snapshotState: states } = require("devtools/client/memory/constants"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + yield front.attach(); + let store = Store(); + + for (let i = 0; i < 5; i++) { + store.dispatch(actions.takeSnapshot(front)); + } + + yield waitUntilState(store, ({ snapshots }) => snapshots.length === 5 && snapshots.every(isDone)); + + for (let i = 0; i < 5; i++) { + do_print(`Selecting snapshot[${i}]`); + store.dispatch(actions.selectSnapshot(store.getState().snapshots[i].id)); + yield waitUntilState(store, ({ snapshots }) => snapshots[i].selected); + + let { snapshots } = store.getState(); + ok(snapshots[i].selected, `snapshot[${i}] selected`); + equal(snapshots.filter(s => !s.selected).length, 4, "All other snapshots are unselected"); + } +}); + +function isDone(s) { return s.state === states.SAVED; } diff --git a/devtools/client/memory/test/unit/test_action-set-display-and-refresh-01.js b/devtools/client/memory/test/unit/test_action-set-display-and-refresh-01.js new file mode 100644 index 000000000..570ffdf05 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-set-display-and-refresh-01.js @@ -0,0 +1,118 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +/** + * Tests the task creator `setCensusDisplayAndRefreshAndRefresh()` for display + * changing. We test this rather than `setCensusDisplayAndRefresh` directly, as + * we use the refresh action in the app itself composed from + * `setCensusDisplayAndRefresh`. + */ + +let { censusDisplays, snapshotState: states, censusState, viewState } = require("devtools/client/memory/constants"); +let { setCensusDisplayAndRefresh } = require("devtools/client/memory/actions/census-display"); +let { takeSnapshotAndCensus, selectSnapshotAndRefresh } = require("devtools/client/memory/actions/snapshot"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +// We test setting an invalid display, which triggers an assertion failure. +EXPECTED_DTU_ASSERT_FAILURE_COUNT = 1; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + // Test default display with no snapshots + equal(getState().censusDisplay.breakdown.by, "coarseType", + "default coarseType display selected at start."); + dispatch(setCensusDisplayAndRefresh(heapWorker, + censusDisplays.allocationStack)); + equal(getState().censusDisplay.breakdown.by, "allocationStack", + "display changed with no snapshots"); + + // Test invalid displays + ok(getState().errors.length === 0, "No error actions in the queue."); + dispatch(setCensusDisplayAndRefresh(heapWorker, {})); + yield waitUntilState(store, () => getState().errors.length === 1); + ok(true, "Emits an error action when passing in an invalid display object"); + + equal(getState().censusDisplay.breakdown.by, "allocationStack", + "current display unchanged when passing invalid display"); + + // Test new snapshots + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED]); + + equal(getState().snapshots[0].census.display, censusDisplays.allocationStack, + "New snapshot's census uses correct display"); + + // Updates when changing display during `SAVING` + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, censusState.SAVING]); + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.coarseType)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, censusState.SAVED]); + equal(getState().snapshots[1].census.display, censusDisplays.coarseType, + "Changing display while saving a snapshot results in a census using the new display"); + + + // Updates when changing display during `SAVING_CENSUS` + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVED, + censusState.SAVING]); + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.allocationStack)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + equal(getState().snapshots[2].census.display, censusDisplays.allocationStack, + "Display can be changed while saving census, stores updated display in snapshot"); + + // Updates census on currently selected snapshot when changing display + ok(getState().snapshots[2].selected, "Third snapshot currently selected"); + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.coarseType)); + yield waitUntilState(store, state => state.snapshots[2].census.state === censusState.SAVING); + yield waitUntilState(store, state => state.snapshots[2].census.state === censusState.SAVED); + equal(getState().snapshots[2].census.display, censusDisplays.coarseType, + "Snapshot census updated when changing displays after already generating one census"); + + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.allocationStack)); + yield waitUntilState(store, state => state.snapshots[2].census.state === censusState.SAVED); + equal(getState().snapshots[2].census.display, censusDisplays.allocationStack, + "Snapshot census updated when changing displays after already generating one census"); + + // Does not update unselected censuses. + ok(!getState().snapshots[1].selected, "Second snapshot selected currently"); + equal(getState().snapshots[1].census.display, censusDisplays.coarseType, + "Second snapshot using `coarseType` display still and not yet updated to correct display"); + + // Updates to current display when switching to stale snapshot. + dispatch(selectSnapshotAndRefresh(heapWorker, getState().snapshots[1].id)); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVING, + censusState.SAVED]); + yield waitUntilCensusState(store, snapshot => snapshot.census, + [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + + ok(getState().snapshots[1].selected, "Second snapshot selected currently"); + equal(getState().snapshots[1].census.display, censusDisplays.allocationStack, + "Second snapshot using `allocationStack` display and updated to correct display"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-set-display-and-refresh-02.js b/devtools/client/memory/test/unit/test_action-set-display-and-refresh-02.js new file mode 100644 index 000000000..5be5444d4 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-set-display-and-refresh-02.js @@ -0,0 +1,53 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +/** + * Tests the task creator `setCensusDisplayAndRefreshAndRefresh()` for custom + * displays. + */ + +let { snapshotState: states, censusState, viewState } = require("devtools/client/memory/constants"); +let { setCensusDisplayAndRefresh } = require("devtools/client/memory/actions/census-display"); +let { takeSnapshotAndCensus } = require("devtools/client/memory/actions/snapshot"); +let { changeView } = require("devtools/client/memory/actions/view"); + +let CUSTOM = { + displayName: "Custom", + tooltip: "Custom tooltip", + inverted: false, + breakdown: { + by: "internalType", + then: { by: "count", bytes: true, count: false } + } +}; + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + dispatch(setCensusDisplayAndRefresh(heapWorker, CUSTOM)); + equal(getState().censusDisplay, CUSTOM, + "CUSTOM display stored in display state."); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + equal(getState().snapshots[0].census.display, CUSTOM, + "New snapshot stored CUSTOM display when done taking census"); + ok(getState().snapshots[0].census.report.children.length, "Census has some children"); + // Ensure we don't have `count` in any results + ok(getState().snapshots[0].census.report.children.every(c => !c.count), + "Census used CUSTOM display without counts"); + // Ensure we do have `bytes` in the results + ok(getState().snapshots[0].census.report.children.every(c => typeof c.bytes === "number"), + "Census used CUSTOM display with bytes"); +}); diff --git a/devtools/client/memory/test/unit/test_action-set-display.js b/devtools/client/memory/test/unit/test_action-set-display.js new file mode 100644 index 000000000..43ea975da --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-set-display.js @@ -0,0 +1,55 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +/** + * Tests the action creator `setCensusDisplay()` for display changing. Does not + * test refreshing the census information, check `setCensusDisplayAndRefresh` + * action for that. + */ + +let { censusDisplays, snapshotState: states, censusState, viewState } = require("devtools/client/memory/constants"); +let { setCensusDisplay } = require("devtools/client/memory/actions/census-display"); +let { takeSnapshotAndCensus } = require("devtools/client/memory/actions/snapshot"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +// We test setting an invalid display, which triggers an assertion failure. +EXPECTED_DTU_ASSERT_FAILURE_COUNT = 1; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + // Test default display with no snapshots + equal(getState().censusDisplay.breakdown.by, "coarseType", + "default coarseType display selected at start."); + + dispatch(setCensusDisplay(censusDisplays.allocationStack)); + equal(getState().censusDisplay.breakdown.by, "allocationStack", + "display changed with no snapshots"); + + // Test invalid displays + try { + dispatch(setCensusDisplay({})); + ok(false, "Throws when passing in an invalid display object"); + } catch (e) { + ok(true, "Throws when passing in an invalid display object"); + } + equal(getState().censusDisplay.breakdown.by, "allocationStack", + "current display unchanged when passing invalid display"); + + // Test new snapshots + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + equal(getState().snapshots[0].census.display, censusDisplays.allocationStack, + "New snapshots use the current, non-default display"); +}); diff --git a/devtools/client/memory/test/unit/test_action-take-census.js b/devtools/client/memory/test/unit/test_action-take-census.js new file mode 100644 index 000000000..3e3d30e8e --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-take-census.js @@ -0,0 +1,59 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * Tests the async reducer responding to the action `takeCensus(heapWorker, snapshot)` + */ + +var { snapshotState: states, censusDisplays, censusState, censusState, viewState } = require("devtools/client/memory/constants"); +var actions = require("devtools/client/memory/actions/snapshot"); +var { changeView } = require("devtools/client/memory/actions/view"); + + +function run_test() { + run_next_test(); +} + +// This tests taking a census on a snapshot that is still being read, which +// triggers an assertion failure. +EXPECTED_DTU_ASSERT_FAILURE_COUNT = 1; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + + store.dispatch(changeView(viewState.CENSUS)); + + store.dispatch(actions.takeSnapshot(front)); + yield waitUntilState(store, () => { + let snapshots = store.getState().snapshots; + return snapshots.length === 1 && snapshots[0].state === states.SAVED; + }); + + let snapshot = store.getState().snapshots[0]; + equal(snapshot.census, null, "No census data exists yet on the snapshot."); + + // Test error case of wrong state. + store.dispatch(actions.takeCensus(heapWorker, snapshot.id)); + yield waitUntilState(store, () => store.getState().errors.length === 1); + + dumpn("Found error: " + store.getState().errors[0]); + ok(/Assertion failure/.test(store.getState().errors[0]), + "Error thrown when taking a census of a snapshot that has not been read."); + + store.dispatch(actions.readSnapshot(heapWorker, snapshot.id)); + yield waitUntilState(store, () => store.getState().snapshots[0].state === states.READ); + + store.dispatch(actions.takeCensus(heapWorker, snapshot.id)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVING]); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + snapshot = store.getState().snapshots[0]; + ok(snapshot.census, "Snapshot has census after saved census"); + ok(snapshot.census.report.children.length, "Census is in tree node form"); + equal(snapshot.census.display, censusDisplays.coarseType, + "Snapshot stored correct display used for the census"); + +}); diff --git a/devtools/client/memory/test/unit/test_action-take-snapshot-and-census.js b/devtools/client/memory/test/unit/test_action-take-snapshot-and-census.js new file mode 100644 index 000000000..77c3b8e38 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-take-snapshot-and-census.js @@ -0,0 +1,58 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * Tests the task creator `takeSnapshotAndCensus()` for the whole flow of + * taking a snapshot, and its sub-actions. + */ + +let { snapshotState: states, treeMapState } = require("devtools/client/memory/constants"); +let actions = require("devtools/client/memory/actions/snapshot"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + + let snapshotI = 0; + let censusI = 0; + let snapshotStates = ["SAVING", "SAVED", "READING", "READ"]; + let censusStates = ["SAVING", "SAVED"]; + let expectStates = () => { + let snapshot = store.getState().snapshots[0]; + if (!snapshot) { + return; + } + if (snapshotI < snapshotStates.length) { + let isCorrectState = snapshot.state === states[snapshotStates[snapshotI]]; + if (isCorrectState) { + ok(true, `Found expected snapshot state ${snapshotStates[snapshotI]}`); + snapshotI++; + } + } + if (snapshot.treeMap && censusI < censusStates.length) { + if (snapshot.treeMap.state === treeMapState[censusStates[censusI]]) { + ok(true, `Found expected census state ${censusStates[censusI]}`); + censusI++; + } + } + }; + + + let unsubscribe = store.subscribe(expectStates); + store.dispatch(actions.takeSnapshotAndCensus(front, heapWorker)); + + yield waitUntilState(store, () => { return snapshotI === snapshotStates.length && + censusI === censusStates.length; }); + unsubscribe(); + + ok(true, "takeSnapshotAndCensus() produces the correct sequence of states in a snapshot"); + let snapshot = store.getState().snapshots[0]; + ok(snapshot.treeMap, "snapshot has tree map census data"); + ok(snapshot.selected, "snapshot is selected"); +}); diff --git a/devtools/client/memory/test/unit/test_action-take-snapshot.js b/devtools/client/memory/test/unit/test_action-take-snapshot.js new file mode 100644 index 000000000..c05583b22 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-take-snapshot.js @@ -0,0 +1,54 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * Tests the async reducer responding to the action `takeSnapshot(front)` + */ + +let actions = require("devtools/client/memory/actions/snapshot"); +let { snapshotState: states } = require("devtools/client/memory/constants"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + yield front.attach(); + let store = Store(); + + let unsubscribe = store.subscribe(checkState); + + let foundPendingState = false; + let foundDoneState = false; + + function checkState() { + let { snapshots } = store.getState(); + let lastSnapshot = snapshots[snapshots.length - 1]; + + if (lastSnapshot.state === states.SAVING) { + foundPendingState = true; + ok(foundPendingState, "Got state change for pending heap snapshot request"); + ok(!lastSnapshot.path, "Snapshot does not yet have a path"); + ok(!lastSnapshot.census, "Has no census data when loading"); + } + else if (lastSnapshot.state === states.SAVED) { + foundDoneState = true; + ok(foundDoneState, "Got state change for completed heap snapshot request"); + ok(foundPendingState, "SAVED state occurs after SAVING state"); + ok(lastSnapshot.path, "Snapshot fetched with a path"); + ok(snapshots.every(s => s.selected === (s.id === lastSnapshot.id)), + "Only recent snapshot is selected"); + } + } + + for (let i = 0; i < 4; i++) { + store.dispatch(actions.takeSnapshot(front)); + yield waitUntilState(store, () => foundPendingState && foundDoneState); + + // reset state trackers + foundDoneState = foundPendingState = false; + } + + unsubscribe(); +}); diff --git a/devtools/client/memory/test/unit/test_action-toggle-inverted-and-refresh-01.js b/devtools/client/memory/test/unit/test_action-toggle-inverted-and-refresh-01.js new file mode 100644 index 000000000..cd015557d --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-toggle-inverted-and-refresh-01.js @@ -0,0 +1,82 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that changing displays with different inverted state properly +// refreshes the selected census. + +const { + censusDisplays, + snapshotState: states, + censusState, + viewState +} = require("devtools/client/memory/constants"); +const { + setCensusDisplayAndRefresh +} = require("devtools/client/memory/actions/census-display"); +const { + takeSnapshotAndCensus, + selectSnapshotAndRefresh, +} = require("devtools/client/memory/actions/snapshot"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + // Select a non-inverted display. + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.allocationStack)); + equal(getState().censusDisplay.inverted, false, "not inverted by default"); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + ok(true, "saved 3 snapshots and took a census of each of them"); + + // Select an inverted display. + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.invertedAllocationStack)); + + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED, + censusState.SAVED, + censusState.SAVING]); + ok(true, "toggling inverted should recompute the selected snapshot's census"); + + equal(getState().censusDisplay.inverted, true, "now inverted"); + + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + + equal(getState().snapshots[0].census.display.inverted, false); + equal(getState().snapshots[1].census.display.inverted, false); + equal(getState().snapshots[2].census.display.inverted, true); + + dispatch(selectSnapshotAndRefresh(heapWorker, getState().snapshots[1].id)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED, + censusState.SAVING, + censusState.SAVED]); + ok(true, "selecting non-inverted census should trigger a recompute"); + + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + + equal(getState().snapshots[0].census.display.inverted, false); + equal(getState().snapshots[1].census.display.inverted, true); + equal(getState().snapshots[2].census.display.inverted, true); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-toggle-inverted-and-refresh-02.js b/devtools/client/memory/test/unit/test_action-toggle-inverted-and-refresh-02.js new file mode 100644 index 000000000..f0cdba264 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-toggle-inverted-and-refresh-02.js @@ -0,0 +1,58 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test that changing inverted state in the middle of taking a snapshot results +// in an inverted census. + +const { censusDisplays, snapshotState: states, censusState, viewState } = require("devtools/client/memory/constants"); +const { takeSnapshotAndCensus } = require("devtools/client/memory/actions/snapshot"); +const { + setCensusDisplay, + setCensusDisplayAndRefresh, +} = require("devtools/client/memory/actions/census-display"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + dispatch(setCensusDisplay(censusDisplays.allocationStack)); + equal(getState().censusDisplay.inverted, false, + "Should not have an inverted census display"); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilSnapshotState(store, [states.SAVING]); + + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.invertedAllocationStack)); + + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + ok(getState().censusDisplay.inverted, + "should want inverted trees"); + ok(getState().snapshots[0].census.display.inverted, + "snapshot-we-were-in-the-middle-of-saving's census should be inverted"); + + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.allocationStack)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVING]); + ok(true, "toggling inverted retriggers census"); + ok(!getState().censusDisplay.inverted, "no longer inverted"); + + dispatch(setCensusDisplayAndRefresh(heapWorker, censusDisplays.invertedAllocationStack)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + ok(getState().censusDisplay.inverted, "inverted again"); + ok(getState().snapshots[0].census.display.inverted, + "census-we-were-in-the-middle-of-recomputing should be inverted again"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action-toggle-inverted.js b/devtools/client/memory/test/unit/test_action-toggle-inverted.js new file mode 100644 index 000000000..665e5d822 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-toggle-inverted.js @@ -0,0 +1,28 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test toggling the top level inversion state of the tree. + +const { censusDisplays } = require("devtools/client/memory/constants"); +const { setCensusDisplay } = require("devtools/client/memory/actions/census-display"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let store = Store(); + const { getState, dispatch } = store; + + dispatch(setCensusDisplay(censusDisplays.allocationStack)); + equal(getState().censusDisplay.inverted, false, + "not inverted initially"); + + dispatch(setCensusDisplay(censusDisplays.invertedAllocationStack)); + equal(getState().censusDisplay.inverted, true, "now inverted after toggling"); + + dispatch(setCensusDisplay(censusDisplays.allocationStack)); + equal(getState().censusDisplay.inverted, false, + "not inverted again after toggling again"); +}); diff --git a/devtools/client/memory/test/unit/test_action-toggle-recording-allocations.js b/devtools/client/memory/test/unit/test_action-toggle-recording-allocations.js new file mode 100644 index 000000000..ebbc17173 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action-toggle-recording-allocations.js @@ -0,0 +1,42 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +/** + * Test toggling the recording of allocation stacks. + */ + +let { toggleRecordingAllocationStacks } = require("devtools/client/memory/actions/allocations"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + equal(getState().allocations.recording, false, "not recording by default"); + equal(getState().allocations.togglingInProgress, false, + "not in the process of toggling by default"); + + dispatch(toggleRecordingAllocationStacks(front)); + yield waitUntilState(store, () => getState().allocations.togglingInProgress); + ok(true, "`togglingInProgress` set to true when toggling on"); + yield waitUntilState(store, () => !getState().allocations.togglingInProgress); + + equal(getState().allocations.recording, true, "now we are recording"); + ok(front.recordingAllocations, "front is recording too"); + + dispatch(toggleRecordingAllocationStacks(front)); + yield waitUntilState(store, () => getState().allocations.togglingInProgress); + ok(true, "`togglingInProgress` set to true when toggling off"); + yield waitUntilState(store, () => !getState().allocations.togglingInProgress); + + equal(getState().allocations.recording, false, "now we are not recording"); + ok(front.recordingAllocations, "front is not recording anymore"); + + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action_diffing_01.js b/devtools/client/memory/test/unit/test_action_diffing_01.js new file mode 100644 index 000000000..24893581e --- /dev/null +++ b/devtools/client/memory/test/unit/test_action_diffing_01.js @@ -0,0 +1,29 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test toggling of diffing. + +const { toggleDiffing } = require("devtools/client/memory/actions/diffing"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + equal(getState().diffing, null, "not diffing by default"); + + dispatch(toggleDiffing()); + ok(getState().diffing, "now diffing after toggling"); + + dispatch(toggleDiffing()); + equal(getState().diffing, null, "not diffing again after toggling again"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action_diffing_02.js b/devtools/client/memory/test/unit/test_action_diffing_02.js new file mode 100644 index 000000000..fc68cee65 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action_diffing_02.js @@ -0,0 +1,46 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that toggling diffing unselects all snapshots. + +const { snapshotState, censusState, viewState } = require("devtools/client/memory/constants"); +const { toggleDiffing } = require("devtools/client/memory/actions/diffing"); +const { takeSnapshotAndCensus } = require("devtools/client/memory/actions/snapshot"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + equal(getState().diffing, null, "not diffing by default"); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED, + censusState.SAVED, + censusState.SAVED]); + + ok(getState().snapshots.some(s => s.selected), + "One of the new snapshots is selected"); + + dispatch(toggleDiffing()); + ok(getState().diffing, "now diffing after toggling"); + + for (let s of getState().snapshots) { + ok(!s.selected, + "No snapshot should be selected after entering diffing mode"); + } + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action_diffing_03.js b/devtools/client/memory/test/unit/test_action_diffing_03.js new file mode 100644 index 000000000..3dd901724 --- /dev/null +++ b/devtools/client/memory/test/unit/test_action_diffing_03.js @@ -0,0 +1,104 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test selecting snapshots for diffing. + +const { diffingState, snapshotState, viewState } = require("devtools/client/memory/constants"); +const { + toggleDiffing, + selectSnapshotForDiffing +} = require("devtools/client/memory/actions/diffing"); +const { takeSnapshot } = require("devtools/client/memory/actions/snapshot"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +// We test that you (1) cannot select a snapshot that is not in a diffable +// state, and (2) cannot select more than 2 snapshots for diffing. Both attempts +// trigger assertion failures. +EXPECTED_DTU_ASSERT_FAILURE_COUNT = 2; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + equal(getState().diffing, null, "not diffing by default"); + + dispatch(takeSnapshot(front, heapWorker)); + dispatch(takeSnapshot(front, heapWorker)); + dispatch(takeSnapshot(front, heapWorker)); + + yield waitUntilSnapshotState(store, [snapshotState.SAVED, + snapshotState.SAVED, + snapshotState.SAVED]); + dispatch(takeSnapshot(front)); + + // Start diffing. + dispatch(toggleDiffing()); + ok(getState().diffing, "now diffing after toggling"); + equal(getState().diffing.firstSnapshotId, null, + "no first snapshot selected"); + equal(getState().diffing.secondSnapshotId, null, + "no second snapshot selected"); + equal(getState().diffing.state, diffingState.SELECTING, + "should be in diffing state SELECTING"); + + // Can't select a snapshot that is not in a diffable state. + equal(getState().snapshots[3].state, snapshotState.SAVING, + "the last snapshot is still in the process of being saved"); + dumpn("Expecting exception:"); + let threw = false; + try { + dispatch(selectSnapshotForDiffing(getState().snapshots[3])); + } catch (error) { + threw = true; + } + ok(threw, "Should not be able to select snapshots that aren't ready for diffing"); + + // Select first snapshot for diffing. + dispatch(selectSnapshotForDiffing(getState().snapshots[0])); + ok(getState().diffing, "now diffing after toggling"); + equal(getState().diffing.firstSnapshotId, getState().snapshots[0].id, + "first snapshot selected"); + equal(getState().diffing.secondSnapshotId, null, + "no second snapshot selected"); + equal(getState().diffing.state, diffingState.SELECTING, + "should still be in diffing state SELECTING"); + + // Can't diff first snapshot with itself; this is a noop. + dispatch(selectSnapshotForDiffing(getState().snapshots[0])); + ok(getState().diffing, "still diffing"); + equal(getState().diffing.firstSnapshotId, getState().snapshots[0].id, + "first snapshot still selected"); + equal(getState().diffing.secondSnapshotId, null, + "still no second snapshot selected"); + equal(getState().diffing.state, diffingState.SELECTING, + "should still be in diffing state SELECTING"); + + // Select second snapshot for diffing. + dispatch(selectSnapshotForDiffing(getState().snapshots[1])); + ok(getState().diffing, "still diffing"); + equal(getState().diffing.firstSnapshotId, getState().snapshots[0].id, + "first snapshot still selected"); + equal(getState().diffing.secondSnapshotId, getState().snapshots[1].id, + "second snapshot selected"); + + // Can't select more than two snapshots for diffing. + dumpn("Expecting exception:"); + threw = false; + try { + dispatch(selectSnapshotForDiffing(getState().snapshots[2])); + } catch (error) { + threw = true; + } + ok(threw, "Can't select more than two snapshots for diffing"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action_diffing_04.js b/devtools/client/memory/test/unit/test_action_diffing_04.js new file mode 100644 index 000000000..2c3cd098b --- /dev/null +++ b/devtools/client/memory/test/unit/test_action_diffing_04.js @@ -0,0 +1,78 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that we compute census diffs. + +const { + diffingState, + snapshotState, + viewState +} = require("devtools/client/memory/constants"); +const { + toggleDiffing, + selectSnapshotForDiffingAndRefresh +} = require("devtools/client/memory/actions/diffing"); +const { + takeSnapshot, + readSnapshot +} = require("devtools/client/memory/actions/snapshot"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + dispatch(changeView(viewState.CENSUS)); + + equal(getState().diffing, null, "not diffing by default"); + + const s1 = yield dispatch(takeSnapshot(front, heapWorker)); + const s2 = yield dispatch(takeSnapshot(front, heapWorker)); + const s3 = yield dispatch(takeSnapshot(front, heapWorker)); + dispatch(readSnapshot(heapWorker, s1)); + dispatch(readSnapshot(heapWorker, s2)); + dispatch(readSnapshot(heapWorker, s3)); + yield waitUntilSnapshotState(store, [snapshotState.READ, + snapshotState.READ, + snapshotState.READ]); + + dispatch(toggleDiffing()); + dispatch(selectSnapshotForDiffingAndRefresh(heapWorker, + getState().snapshots[0])); + dispatch(selectSnapshotForDiffingAndRefresh(heapWorker, + getState().snapshots[1])); + + ok(getState().diffing, "We should be diffing."); + equal(getState().diffing.firstSnapshotId, getState().snapshots[0].id, + "First snapshot selected."); + equal(getState().diffing.secondSnapshotId, getState().snapshots[1].id, + "Second snapshot selected."); + + yield waitUntilState(store, + state => + state.diffing.state === diffingState.TAKING_DIFF); + ok(true, + "Selecting two snapshots for diffing should trigger computing a diff."); + + yield waitUntilState(store, + state => state.diffing.state === diffingState.TOOK_DIFF); + ok(true, "And then the diff should complete."); + ok(getState().diffing.census, "And we should have a census."); + ok(getState().diffing.census.report, "And that census should have a report."); + equal(getState().diffing.census.display, getState().censusDisplay, + "And that census should have the correct display"); + equal(getState().diffing.census.filter, getState().filter, + "And that census should have the correct filter"); + equal(getState().diffing.census.display.inverted, + getState().censusDisplay.inverted, + "And that census should have the correct inversion"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_action_diffing_05.js b/devtools/client/memory/test/unit/test_action_diffing_05.js new file mode 100644 index 000000000..e4a1491ac --- /dev/null +++ b/devtools/client/memory/test/unit/test_action_diffing_05.js @@ -0,0 +1,112 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that we recompute census diffs at the appropriate times. + +const { + diffingState, + snapshotState, + censusDisplays, + viewState, +} = require("devtools/client/memory/constants"); +const { + setCensusDisplayAndRefresh, +} = require("devtools/client/memory/actions/census-display"); +const { + toggleDiffing, + selectSnapshotForDiffingAndRefresh, +} = require("devtools/client/memory/actions/diffing"); +const { + setFilterStringAndRefresh, +} = require("devtools/client/memory/actions/filter"); +const { + takeSnapshot, + readSnapshot, +} = require("devtools/client/memory/actions/snapshot"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + dispatch(changeView(viewState.CENSUS)); + + yield dispatch(setCensusDisplayAndRefresh(heapWorker, + censusDisplays.allocationStack)); + equal(getState().censusDisplay.inverted, false, + "not inverted at start"); + + equal(getState().diffing, null, "not diffing by default"); + + const s1 = yield dispatch(takeSnapshot(front, heapWorker)); + const s2 = yield dispatch(takeSnapshot(front, heapWorker)); + const s3 = yield dispatch(takeSnapshot(front, heapWorker)); + dispatch(readSnapshot(heapWorker, s1)); + dispatch(readSnapshot(heapWorker, s2)); + dispatch(readSnapshot(heapWorker, s3)); + yield waitUntilSnapshotState(store, [snapshotState.READ, + snapshotState.READ, + snapshotState.READ]); + + yield dispatch(toggleDiffing()); + dispatch(selectSnapshotForDiffingAndRefresh(heapWorker, + getState().snapshots[0])); + dispatch(selectSnapshotForDiffingAndRefresh(heapWorker, + getState().snapshots[1])); + yield waitUntilState(store, + state => state.diffing.state === diffingState.TOOK_DIFF); + + const shouldTriggerRecompute = [ + { + name: "toggling inversion", + func: () => dispatch(setCensusDisplayAndRefresh( + heapWorker, + censusDisplays.invertedAllocationStack)) + }, + { + name: "filtering", + func: () => dispatch(setFilterStringAndRefresh("scr", heapWorker)) + }, + { + name: "changing displays", + func: () => + dispatch(setCensusDisplayAndRefresh(heapWorker, + censusDisplays.coarseType)) + } + ]; + + for (let { name, func } of shouldTriggerRecompute) { + dumpn(`Testing that "${name}" triggers a diff recompute`); + func(); + + yield waitUntilState(store, + state => + state.diffing.state === diffingState.TAKING_DIFF); + ok(true, "triggered diff recompute."); + + yield waitUntilState(store, + state => + state.diffing.state === diffingState.TOOK_DIFF); + ok(true, "And then the diff should complete."); + ok(getState().diffing.census, "And we should have a census."); + ok(getState().diffing.census.report, + "And that census should have a report."); + equal(getState().diffing.census.display, + getState().censusDisplay, + "And that census should have the correct display"); + equal(getState().diffing.census.filter, getState().filter, + "And that census should have the correct filter"); + equal(getState().diffing.census.display.inverted, + getState().censusDisplay.inverted, + "And that census should have the correct inversion"); + } + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_01.js b/devtools/client/memory/test/unit/test_dominator_trees_01.js new file mode 100644 index 000000000..5fcf441d4 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_01.js @@ -0,0 +1,61 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that we can compute and fetch the dominator tree for a snapshot. + +let { + snapshotState: states, + dominatorTreeState, + treeMapState, +} = require("devtools/client/memory/constants"); +let { + takeSnapshotAndCensus, + computeAndFetchDominatorTree, +} = require("devtools/client/memory/actions/snapshot"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.treeMap, [treeMapState.SAVED]); + ok(!getState().snapshots[0].dominatorTree, + "There shouldn't be a dominator tree model yet since it is not computed " + + "until we switch to the dominators view."); + + // Change to the dominator tree view. + dispatch(computeAndFetchDominatorTree(heapWorker, getState().snapshots[0].id)); + ok(getState().snapshots[0].dominatorTree, + "Should now have a dominator tree model for the selected snapshot"); + + // Wait for the dominator tree to start being computed. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.COMPUTING); + ok(true, "The dominator tree started computing"); + ok(!getState().snapshots[0].dominatorTree.root, + "When the dominator tree is computing, we should not have its root"); + + // Wait for the dominator tree to finish computing and start being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.FETCHING); + ok(true, "The dominator tree started fetching"); + ok(!getState().snapshots[0].dominatorTree.root, + "When the dominator tree is fetching, we should not have its root"); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, "The dominator tree was fetched"); + ok(getState().snapshots[0].dominatorTree.root, + "When the dominator tree is loaded, we should have its root"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_02.js b/devtools/client/memory/test/unit/test_dominator_trees_02.js new file mode 100644 index 000000000..b35961004 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_02.js @@ -0,0 +1,64 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that selecting the dominator tree view automatically kicks off fetching +// and computing dominator trees. + +const { + snapshotState: states, + dominatorTreeState, + viewState, + treeMapState, +} = require("devtools/client/memory/constants"); +const { + takeSnapshotAndCensus, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeViewAndRefresh +} = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.treeMap, [treeMapState.SAVED]); + ok(!getState().snapshots[0].dominatorTree, + "There shouldn't be a dominator tree model yet since it is not computed " + + "until we switch to the dominators view."); + + dispatch(changeViewAndRefresh(viewState.DOMINATOR_TREE, heapWorker)); + ok(getState().snapshots[0].dominatorTree, + "Should now have a dominator tree model for the selected snapshot"); + + // Wait for the dominator tree to start being computed. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.COMPUTING); + ok(true, "The dominator tree started computing"); + ok(!getState().snapshots[0].dominatorTree.root, + "When the dominator tree is computing, we should not have its root"); + + // Wait for the dominator tree to finish computing and start being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.FETCHING); + ok(true, "The dominator tree started fetching"); + ok(!getState().snapshots[0].dominatorTree.root, + "When the dominator tree is fetching, we should not have its root"); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, "The dominator tree was fetched"); + ok(getState().snapshots[0].dominatorTree.root, + "When the dominator tree is loaded, we should have its root"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_03.js b/devtools/client/memory/test/unit/test_dominator_trees_03.js new file mode 100644 index 000000000..09e6477f4 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_03.js @@ -0,0 +1,61 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that selecting the dominator tree view and then taking a snapshot +// properly kicks off fetching and computing dominator trees. + +const { + snapshotState: states, + dominatorTreeState, + viewState, +} = require("devtools/client/memory/constants"); +const { + takeSnapshotAndCensus, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView +} = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.DOMINATOR_TREE)); + equal(getState().view.state, viewState.DOMINATOR_TREE, + "We should now be in the DOMINATOR_TREE view"); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + + // Wait for the dominator tree to start being computed. + yield waitUntilState(store, state => + state.snapshots[0] && state.snapshots[0].dominatorTree); + equal(getState().snapshots[0].dominatorTree.state, + dominatorTreeState.COMPUTING, + "The dominator tree started computing"); + ok(!getState().snapshots[0].dominatorTree.root, + "When the dominator tree is computing, we should not have its root"); + + // Wait for the dominator tree to finish computing and start being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.FETCHING); + ok(true, "The dominator tree started fetching"); + ok(!getState().snapshots[0].dominatorTree.root, + "When the dominator tree is fetching, we should not have its root"); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, "The dominator tree was fetched"); + ok(getState().snapshots[0].dominatorTree.root, + "When the dominator tree is loaded, we should have its root"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_04.js b/devtools/client/memory/test/unit/test_dominator_trees_04.js new file mode 100644 index 000000000..ba375c354 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_04.js @@ -0,0 +1,69 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that selecting the dominator tree view while in the middle of taking a +// snapshot properly kicks off fetching and computing dominator trees. + +const { + snapshotState: states, + dominatorTreeState, + viewState, +} = require("devtools/client/memory/constants"); +const { + takeSnapshotAndCensus, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView +} = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + + for (let intermediateSnapshotState of [states.SAVING, + states.READING, + states.READ]) { + dumpn(`Testing switching to the DOMINATOR_TREE view in the middle of the ${intermediateSnapshotState} snapshot state`); + + let store = Store(); + let { getState, dispatch } = store; + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilSnapshotState(store, [intermediateSnapshotState]); + + dispatch(changeView(viewState.DOMINATOR_TREE)); + equal(getState().view.state, viewState.DOMINATOR_TREE, + "We should now be in the DOMINATOR_TREE view"); + + // Wait for the dominator tree to start being computed. + yield waitUntilState(store, state => + state.snapshots[0] && state.snapshots[0].dominatorTree); + equal(getState().snapshots[0].dominatorTree.state, + dominatorTreeState.COMPUTING, + "The dominator tree started computing"); + ok(!getState().snapshots[0].dominatorTree.root, + "When the dominator tree is computing, we should not have its root"); + + // Wait for the dominator tree to finish computing and start being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.FETCHING); + ok(true, "The dominator tree started fetching"); + ok(!getState().snapshots[0].dominatorTree.root, + "When the dominator tree is fetching, we should not have its root"); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, "The dominator tree was fetched"); + ok(getState().snapshots[0].dominatorTree.root, + "When the dominator tree is loaded, we should have its root"); + } + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_05.js b/devtools/client/memory/test/unit/test_dominator_trees_05.js new file mode 100644 index 000000000..42ea13e18 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_05.js @@ -0,0 +1,59 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that changing the currently selected snapshot to a snapshot that does +// not have a dominator tree will automatically compute and fetch one for it. + +let { + snapshotState: states, + dominatorTreeState, + viewState, + treeMapState, +} = require("devtools/client/memory/constants"); +let { + takeSnapshotAndCensus, + selectSnapshotAndRefresh, +} = require("devtools/client/memory/actions/snapshot"); + +let { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.treeMap, [treeMapState.SAVED, + treeMapState.SAVED]); + + ok(getState().snapshots[1].selected, "The second snapshot is selected"); + + // Change to the dominator tree view. + dispatch(changeView(viewState.DOMINATOR_TREE)); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[1].dominatorTree && + state.snapshots[1].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, "The second snapshot's dominator tree was fetched"); + + // Select the first snapshot. + dispatch(selectSnapshotAndRefresh(heapWorker, getState().snapshots[0].id)); + + // And now the first snapshot should have its dominator tree fetched and + // computed because of the new selection. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree && + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, "The first snapshot's dominator tree was fetched"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_06.js b/devtools/client/memory/test/unit/test_dominator_trees_06.js new file mode 100644 index 000000000..78f869102 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_06.js @@ -0,0 +1,127 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that we can incrementally fetch a subtree of a dominator tree. + +const { + snapshotState: states, + dominatorTreeState, + viewState, +} = require("devtools/client/memory/constants"); +const { + takeSnapshotAndCensus, + selectSnapshotAndRefresh, + fetchImmediatelyDominated, +} = require("devtools/client/memory/actions/snapshot"); +const DominatorTreeLazyChildren + = require("devtools/client/memory/dominator-tree-lazy-children"); + +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.DOMINATOR_TREE)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0] && + state.snapshots[0].dominatorTree && + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(getState().snapshots[0].dominatorTree.root, + "The dominator tree was fetched"); + + // Find a node that has children, but none of them are loaded. + + function findNode(node) { + if (node.moreChildrenAvailable && !node.children) { + return node; + } + + if (node.children) { + for (let child of node.children) { + const found = findNode(child); + if (found) { + return found; + } + } + } + + return null; + } + + const oldRoot = getState().snapshots[0].dominatorTree.root; + const oldNode = findNode(oldRoot); + ok(oldNode, + "Should have found a node with children that are not loaded since we " + + "only send partial dominator trees across initially and load the rest " + + "on demand"); + ok(oldNode !== oldRoot, "But the node should not be the root"); + + const lazyChildren = new DominatorTreeLazyChildren(oldNode.nodeId, 0); + dispatch(fetchImmediatelyDominated(heapWorker, getState().snapshots[0].id, lazyChildren)); + + equal(getState().snapshots[0].dominatorTree.state, + dominatorTreeState.INCREMENTAL_FETCHING, + "Fetching immediately dominated children should put us in the " + + "INCREMENTAL_FETCHING state"); + + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, + "The dominator tree should go back to LOADED after the incremental " + + "fetching is done."); + + const newRoot = getState().snapshots[0].dominatorTree.root; + ok(oldRoot !== newRoot, + "When we insert new nodes, we get a new tree"); + equal(oldRoot.children.length, newRoot.children.length, + "The new tree's root should have the same number of children as the " + + "old root's"); + + let differentChildrenCount = 0; + for (let i = 0; i < oldRoot.children.length; i++) { + if (oldRoot.children[i] !== newRoot.children[i]) { + differentChildrenCount++; + } + } + equal(differentChildrenCount, 1, + "All subtrees except the subtree we inserted incrementally fetched " + + "children into should be the same because we use persistent updates"); + + // Find the new node which has the children inserted. + + function findNewNode(node) { + if (node.nodeId === oldNode.nodeId) { + return node; + } + + if (node.children) { + for (let child of node.children) { + const found = findNewNode(child); + if (found) { + return found; + } + } + } + + return null; + } + + const newNode = findNewNode(newRoot); + ok(newNode, "Should find the node in the new tree again"); + ok(newNode !== oldNode, "We did not mutate the old node in place, instead created a new node"); + ok(newNode.children, "And the new node should have the children attached"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_07.js b/devtools/client/memory/test/unit/test_dominator_trees_07.js new file mode 100644 index 000000000..9121fc878 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_07.js @@ -0,0 +1,146 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that we can incrementally fetch two subtrees in the same dominator tree +// concurrently. This exercises the activeFetchRequestCount machinery. + +const { + snapshotState: states, + dominatorTreeState, + viewState, +} = require("devtools/client/memory/constants"); +const { + takeSnapshotAndCensus, + selectSnapshotAndRefresh, + fetchImmediatelyDominated, +} = require("devtools/client/memory/actions/snapshot"); +const DominatorTreeLazyChildren + = require("devtools/client/memory/dominator-tree-lazy-children"); + +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.DOMINATOR_TREE)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0] && + state.snapshots[0].dominatorTree && + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(getState().snapshots[0].dominatorTree.root, + "The dominator tree was fetched"); + + // Find a node that has more children. + + function findNode(node) { + if (node.moreChildrenAvailable && !node.children) { + return node; + } + + if (node.children) { + for (let child of node.children) { + const found = findNode(child); + if (found) { + return found; + } + } + } + + return null; + } + + const oldRoot = getState().snapshots[0].dominatorTree.root; + const oldNode = findNode(oldRoot); + ok(oldNode, "Should have found a node with more children."); + + // Find another node that has more children. + function findNodeRev(node) { + if (node.moreChildrenAvailable && !node.children) { + return node; + } + + if (node.children) { + for (let child of node.children.slice().reverse()) { + const found = findNodeRev(child); + if (found) { + return found; + } + } + } + + return null; + } + + const oldNode2 = findNodeRev(oldRoot); + ok(oldNode2, "Should have found another node with more children."); + ok(oldNode !== oldNode2, + "The second node should not be the same as the first one"); + + // Fetch both subtrees concurrently. + dispatch(fetchImmediatelyDominated(heapWorker, getState().snapshots[0].id, + new DominatorTreeLazyChildren(oldNode.nodeId, 0))); + dispatch(fetchImmediatelyDominated(heapWorker, getState().snapshots[0].id, + new DominatorTreeLazyChildren(oldNode2.nodeId, 0))); + + equal(getState().snapshots[0].dominatorTree.state, + dominatorTreeState.INCREMENTAL_FETCHING, + "Fetching immediately dominated children should put us in the " + + "INCREMENTAL_FETCHING state"); + + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, + "The dominator tree should go back to LOADED after the incremental " + + "fetching is done."); + + const newRoot = getState().snapshots[0].dominatorTree.root; + ok(oldRoot !== newRoot, + "When we insert new nodes, we get a new tree"); + + // Find the new node which has the children inserted. + + function findNodeWithId(id, node) { + if (node.nodeId === id) { + return node; + } + + if (node.children) { + for (let child of node.children) { + const found = findNodeWithId(id, child); + if (found) { + return found; + } + } + } + + return null; + } + + const newNode = findNodeWithId(oldNode.nodeId, newRoot); + ok(newNode, "Should find the node in the new tree again"); + ok(newNode !== oldNode, + "We did not mutate the old node in place, instead created a new node"); + ok(newNode.children.length, + "And the new node should have the new children attached"); + + const newNode2 = findNodeWithId(oldNode2.nodeId, newRoot); + ok(newNode2, "Should find the second node in the new tree again"); + ok(newNode2 !== oldNode2, + "We did not mutate the second old node in place, instead created a new node"); + ok(newNode2.children, + "And the new node should have the new children attached"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_08.js b/devtools/client/memory/test/unit/test_dominator_trees_08.js new file mode 100644 index 000000000..27f35180c --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_08.js @@ -0,0 +1,81 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that we can change the display with which we describe a dominator tree +// and that the dominator tree is re-fetched. + +const { + snapshotState: states, + dominatorTreeState, + viewState, + labelDisplays, + treeMapState +} = require("devtools/client/memory/constants"); +const { + setLabelDisplayAndRefresh +} = require("devtools/client/memory/actions/label-display"); +const { + changeView, +} = require("devtools/client/memory/actions/view"); +const { + takeSnapshotAndCensus, + computeAndFetchDominatorTree, +} = require("devtools/client/memory/actions/snapshot"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.DOMINATOR_TREE)); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.treeMap, [treeMapState.SAVED]); + ok(!getState().snapshots[0].dominatorTree, + "There shouldn't be a dominator tree model yet since it is not computed " + + "until we switch to the dominators view."); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0] && + state.snapshots[0].dominatorTree && + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + + ok(getState().labelDisplay, + "We have a default display for describing nodes in a dominator tree"); + equal(getState().labelDisplay, + labelDisplays.coarseType, + "and the default is coarse type"); + equal(getState().labelDisplay, + getState().snapshots[0].dominatorTree.display, + "and the newly computed dominator tree has that display"); + + // Switch to the allocationStack display. + dispatch(setLabelDisplayAndRefresh( + heapWorker, + labelDisplays.allocationStack)); + + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.FETCHING); + ok(true, + "switching display types caused the dominator tree to be fetched " + + "again."); + + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + equal(getState().snapshots[0].dominatorTree.display, + labelDisplays.allocationStack, + "The new dominator tree's display is allocationStack"); + equal(getState().labelDisplay, + labelDisplays.allocationStack, + "as is our requested dominator tree display"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_09.js b/devtools/client/memory/test/unit/test_dominator_trees_09.js new file mode 100644 index 000000000..c1d1f7495 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_09.js @@ -0,0 +1,78 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that we can change the display with which we describe a dominator tree +// while the dominator tree is in the middle of being fetched. + +const { + snapshotState: states, + dominatorTreeState, + viewState, + labelDisplays, + treeMapState, +} = require("devtools/client/memory/constants"); +const { + setLabelDisplayAndRefresh +} = require("devtools/client/memory/actions/label-display"); +const { + changeView, +} = require("devtools/client/memory/actions/view"); +const { + takeSnapshotAndCensus, + computeAndFetchDominatorTree, +} = require("devtools/client/memory/actions/snapshot"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.DOMINATOR_TREE)); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.treeMap, [treeMapState.SAVED]); + ok(!getState().snapshots[0].dominatorTree, + "There shouldn't be a dominator tree model yet since it is not computed " + + "until we switch to the dominators view."); + + // Wait for the dominator tree to start fetching. + yield waitUntilState(store, state => + state.snapshots[0] && + state.snapshots[0].dominatorTree && + state.snapshots[0].dominatorTree.state === dominatorTreeState.FETCHING); + + ok(getState().labelDisplay, + "We have a default display for describing nodes in a dominator tree"); + equal(getState().labelDisplay, + labelDisplays.coarseType, + "and the default is coarse type"); + equal(getState().labelDisplay, + getState().snapshots[0].dominatorTree.display, + "and the newly computed dominator tree has that display"); + + // Switch to the allocationStack display while we are still fetching the + // dominator tree. + dispatch(setLabelDisplayAndRefresh( + heapWorker, + labelDisplays.allocationStack)); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + + equal(getState().snapshots[0].dominatorTree.display, + labelDisplays.allocationStack, + "The new dominator tree's display is allocationStack"); + equal(getState().labelDisplay, + labelDisplays.allocationStack, + "as is our requested dominator tree display"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_dominator_trees_10.js b/devtools/client/memory/test/unit/test_dominator_trees_10.js new file mode 100644 index 000000000..f7cf86a10 --- /dev/null +++ b/devtools/client/memory/test/unit/test_dominator_trees_10.js @@ -0,0 +1,74 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test that we maintain focus of the selected dominator tree node across +// changing breakdowns for labeling them. + +let { + snapshotState: states, + dominatorTreeState, + labelDisplays, + viewState, +} = require("devtools/client/memory/constants"); +let { + takeSnapshotAndCensus, + focusDominatorTreeNode, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView, +} = require("devtools/client/memory/actions/view"); +const { + setLabelDisplayAndRefresh, +} = require("devtools/client/memory/actions/label-display"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.DOMINATOR_TREE)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + + // Wait for the dominator tree to finish being fetched. + yield waitUntilState(store, state => + state.snapshots[0] && + state.snapshots[0].dominatorTree && + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, "The dominator tree was fetched"); + + const root = getState().snapshots[0].dominatorTree.root; + ok(root, "When the dominator tree is loaded, we should have its root"); + + dispatch(focusDominatorTreeNode(getState().snapshots[0].id, root)); + equal(root, getState().snapshots[0].dominatorTree.focused, + "The root should be focused."); + + equal(getState().labelDisplay, labelDisplays.coarseType, + "Using labelDisplays.coarseType by default"); + dispatch(setLabelDisplayAndRefresh(heapWorker, + labelDisplays.allocationStack)); + equal(getState().labelDisplay, labelDisplays.allocationStack, + "Using labelDisplays.allocationStack now"); + + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.FETCHING); + ok(true, "We started re-fetching the dominator tree"); + + yield waitUntilState(store, state => + state.snapshots[0].dominatorTree.state === dominatorTreeState.LOADED); + ok(true, "The dominator tree was loaded again"); + + ok(getState().snapshots[0].dominatorTree.focused, + "Still have a focused node"); + equal(getState().snapshots[0].dominatorTree.focused.nodeId, root.nodeId, + "Focused node is the same as before"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_individuals_01.js b/devtools/client/memory/test/unit/test_individuals_01.js new file mode 100644 index 000000000..36971a7dc --- /dev/null +++ b/devtools/client/memory/test/unit/test_individuals_01.js @@ -0,0 +1,76 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Basic test for switching to the individuals view. + +const { + censusState, + viewState, + individualsState, +} = require("devtools/client/memory/constants"); +const { + fetchIndividuals, + takeSnapshotAndCensus, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView, +} = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +const EXPECTED_INDIVIDUAL_STATES = [ + individualsState.COMPUTING_DOMINATOR_TREE, + individualsState.FETCHING, + individualsState.FETCHED, +]; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + equal(getState().individuals, null, + "no individuals state by default"); + + dispatch(changeView(viewState.CENSUS)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + const root = getState().snapshots[0].census.report; + ok(root, "Should have a census"); + + const reportLeafIndex = findReportLeafIndex(root); + ok(reportLeafIndex, "Should get a reportLeafIndex"); + + const snapshotId = getState().snapshots[0].id; + ok(snapshotId, "Should have a snapshot id"); + + const breakdown = getState().snapshots[0].census.display.breakdown; + ok(breakdown, "Should have a breakdown"); + + dispatch(fetchIndividuals(heapWorker, snapshotId, breakdown, + reportLeafIndex)); + + // Wait for each expected state. + for (let state of EXPECTED_INDIVIDUAL_STATES) { + yield waitUntilState(store, s => { + return s.view.state === viewState.INDIVIDUALS && + s.individuals && + s.individuals.state === state; + }); + ok(true, `Reached state = ${state}`); + } + + ok(getState().individuals, "Should have individuals state"); + ok(getState().individuals.nodes, "Should have individuals nodes"); + ok(getState().individuals.nodes.length > 0, + "Should have a positive number of nodes"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_individuals_02.js b/devtools/client/memory/test/unit/test_individuals_02.js new file mode 100644 index 000000000..9e23e2c4f --- /dev/null +++ b/devtools/client/memory/test/unit/test_individuals_02.js @@ -0,0 +1,88 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test switching to the individuals view when we are in the middle of computing +// a dominator tree. + +const { + censusState, + dominatorTreeState, + viewState, + individualsState, +} = require("devtools/client/memory/constants"); +const { + fetchIndividuals, + takeSnapshotAndCensus, + computeDominatorTree, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView, +} = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +const EXPECTED_INDIVIDUAL_STATES = [ + individualsState.COMPUTING_DOMINATOR_TREE, + individualsState.FETCHING, + individualsState.FETCHED, +]; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + equal(getState().individuals, null, + "no individuals state by default"); + + dispatch(changeView(viewState.CENSUS)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + const root = getState().snapshots[0].census.report; + ok(root, "Should have a census"); + + const reportLeafIndex = findReportLeafIndex(root); + ok(reportLeafIndex, "Should get a reportLeafIndex"); + + const snapshotId = getState().snapshots[0].id; + ok(snapshotId, "Should have a snapshot id"); + + const breakdown = getState().snapshots[0].census.display.breakdown; + ok(breakdown, "Should have a breakdown"); + + // Start computing a dominator tree. + + dispatch(computeDominatorTree(heapWorker, snapshotId)); + equal(getState().snapshots[0].dominatorTree.state, + dominatorTreeState.COMPUTING, + "Should be computing dominator tree"); + + // Fetch individuals in the middle of computing the dominator tree. + + dispatch(fetchIndividuals(heapWorker, snapshotId, breakdown, + reportLeafIndex)); + + // Wait for each expected state. + for (let state of EXPECTED_INDIVIDUAL_STATES) { + yield waitUntilState(store, s => { + return s.view.state === viewState.INDIVIDUALS && + s.individuals && + s.individuals.state === state; + }); + ok(true, `Reached state = ${state}`); + } + + ok(getState().individuals, "Should have individuals state"); + ok(getState().individuals.nodes, "Should have individuals nodes"); + ok(getState().individuals.nodes.length > 0, + "Should have a positive number of nodes"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_individuals_03.js b/devtools/client/memory/test/unit/test_individuals_03.js new file mode 100644 index 000000000..54460b737 --- /dev/null +++ b/devtools/client/memory/test/unit/test_individuals_03.js @@ -0,0 +1,106 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test switching to the individuals view when we are in the diffing view. + +const { + censusState, + diffingState, + viewState, + individualsState, +} = require("devtools/client/memory/constants"); +const { + fetchIndividuals, + takeSnapshotAndCensus, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView, + popViewAndRefresh, +} = require("devtools/client/memory/actions/view"); +const { + selectSnapshotForDiffingAndRefresh, +} = require("devtools/client/memory/actions/diffing"); + +function run_test() { + run_next_test(); +} + +const EXPECTED_INDIVIDUAL_STATES = [ + individualsState.COMPUTING_DOMINATOR_TREE, + individualsState.FETCHING, + individualsState.FETCHED, +]; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + // Take two snapshots and diff them from each other. + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED, + censusState.SAVED]); + + dispatch(changeView(viewState.DIFFING)); + dispatch(selectSnapshotForDiffingAndRefresh(heapWorker, getState().snapshots[0])); + dispatch(selectSnapshotForDiffingAndRefresh(heapWorker, getState().snapshots[1])); + + yield waitUntilState(store, state => { + return state.diffing && + state.diffing.state === diffingState.TOOK_DIFF; + }); + ok(getState().diffing.census); + + // Fetch individuals. + + const root = getState().diffing.census.report; + ok(root, "Should have a census"); + + const reportLeafIndex = findReportLeafIndex(root); + ok(reportLeafIndex, "Should get a reportLeafIndex"); + + const snapshotId = getState().diffing.secondSnapshotId; + ok(snapshotId, "Should have a snapshot id"); + + const breakdown = getState().censusDisplay.breakdown; + ok(breakdown, "Should have a breakdown"); + + dispatch(fetchIndividuals(heapWorker, snapshotId, breakdown, + reportLeafIndex)); + + for (let state of EXPECTED_INDIVIDUAL_STATES) { + yield waitUntilState(store, s => { + return s.view.state === viewState.INDIVIDUALS && + s.individuals && + s.individuals.state === state; + }); + ok(true, `Reached state = ${state}`); + } + + ok(getState().individuals, "Should have individuals state"); + ok(getState().individuals.nodes, "Should have individuals nodes"); + ok(getState().individuals.nodes.length > 0, + "Should have a positive number of nodes"); + + // Pop the view back to the diffing. + + dispatch(popViewAndRefresh(heapWorker)); + + yield waitUntilState(store, state => { + return state.diffing && + state.diffing.state === diffingState.TOOK_DIFF; + }); + + ok(getState().diffing.census.report, + "We have our census diff again after popping back to the last view"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_individuals_04.js b/devtools/client/memory/test/unit/test_individuals_04.js new file mode 100644 index 000000000..c160d555f --- /dev/null +++ b/devtools/client/memory/test/unit/test_individuals_04.js @@ -0,0 +1,89 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test showing individual Array objects. + +const { + censusState, + viewState, + individualsState, +} = require("devtools/client/memory/constants"); +const { + fetchIndividuals, + takeSnapshotAndCensus, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView, +} = require("devtools/client/memory/actions/view"); +const { + setFilterString, +} = require("devtools/client/memory/actions/filter"); + +function run_test() { + run_next_test(); +} + +const EXPECTED_INDIVIDUAL_STATES = [ + individualsState.COMPUTING_DOMINATOR_TREE, + individualsState.FETCHING, + individualsState.FETCHED, +]; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + dispatch(setFilterString("Array")); + + // Take a snapshot and wait for the census to finish. + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + // Fetch individuals. + + const root = getState().snapshots[0].census.report; + ok(root, "Should have a census"); + + const reportLeafIndex = findReportLeafIndex(root, "Array"); + ok(reportLeafIndex, "Should get a reportLeafIndex for Array"); + + const snapshotId = getState().snapshots[0].id; + ok(snapshotId, "Should have a snapshot id"); + + const breakdown = getState().censusDisplay.breakdown; + ok(breakdown, "Should have a breakdown"); + + dispatch(fetchIndividuals(heapWorker, snapshotId, breakdown, + reportLeafIndex)); + + for (let state of EXPECTED_INDIVIDUAL_STATES) { + yield waitUntilState(store, s => { + return s.view.state === viewState.INDIVIDUALS && + s.individuals && + s.individuals.state === state; + }); + ok(true, `Reached state = ${state}`); + } + + ok(getState().individuals, "Should have individuals state"); + ok(getState().individuals.nodes, "Should have individuals nodes"); + ok(getState().individuals.nodes.length > 0, + "Should have a positive number of nodes"); + + // Assert that all the individuals are `Array`s. + + for (let node of getState().individuals.nodes) { + dumpn("Checking node: " + node.label.join(" > ")); + ok(node.label.find(part => part === "Array"), + "The node should be an Array node"); + } + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_individuals_05.js b/devtools/client/memory/test/unit/test_individuals_05.js new file mode 100644 index 000000000..1f8873826 --- /dev/null +++ b/devtools/client/memory/test/unit/test_individuals_05.js @@ -0,0 +1,82 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test showing individual objects that do not have allocation stacks. + +const { + censusState, + viewState, + individualsState, + censusDisplays, +} = require("devtools/client/memory/constants"); +const { + fetchIndividuals, + takeSnapshotAndCensus, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView, +} = require("devtools/client/memory/actions/view"); +const { + setCensusDisplay, +} = require("devtools/client/memory/actions/census-display"); + +function run_test() { + run_next_test(); +} + +const EXPECTED_INDIVIDUAL_STATES = [ + individualsState.COMPUTING_DOMINATOR_TREE, + individualsState.FETCHING, + individualsState.FETCHED, +]; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + dispatch(setCensusDisplay(censusDisplays.invertedAllocationStack)); + + // Take a snapshot and wait for the census to finish. + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + // Fetch individuals. + + const root = getState().snapshots[0].census.report; + ok(root, "Should have a census"); + + const reportLeafIndex = findReportLeafIndex(root, "noStack"); + ok(reportLeafIndex, "Should get a reportLeafIndex for noStack"); + + const snapshotId = getState().snapshots[0].id; + ok(snapshotId, "Should have a snapshot id"); + + const breakdown = getState().censusDisplay.breakdown; + ok(breakdown, "Should have a breakdown"); + + dispatch(fetchIndividuals(heapWorker, snapshotId, breakdown, + reportLeafIndex)); + + for (let state of EXPECTED_INDIVIDUAL_STATES) { + yield waitUntilState(store, s => { + return s.view.state === viewState.INDIVIDUALS && + s.individuals && + s.individuals.state === state; + }); + ok(true, `Reached state = ${state}`); + } + + ok(getState().individuals, "Should have individuals state"); + ok(getState().individuals.nodes, "Should have individuals nodes"); + ok(getState().individuals.nodes.length > 0, + "Should have a positive number of nodes"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_individuals_06.js b/devtools/client/memory/test/unit/test_individuals_06.js new file mode 100644 index 000000000..6147b8181 --- /dev/null +++ b/devtools/client/memory/test/unit/test_individuals_06.js @@ -0,0 +1,84 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test that clearing the current individuals' snapshot leaves the individuals +// view. + +const { + censusState, + viewState, + individualsState, +} = require("devtools/client/memory/constants"); +const { + fetchIndividuals, + takeSnapshotAndCensus, + clearSnapshots, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView, +} = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +const EXPECTED_INDIVIDUAL_STATES = [ + individualsState.COMPUTING_DOMINATOR_TREE, + individualsState.FETCHING, + individualsState.FETCHED, +]; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + // Take a snapshot and wait for the census to finish. + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + // Fetch individuals. + + const root = getState().snapshots[0].census.report; + ok(root, "Should have a census"); + + const reportLeafIndex = findReportLeafIndex(root); + ok(reportLeafIndex, "Should get a reportLeafIndex"); + + const snapshotId = getState().snapshots[0].id; + ok(snapshotId, "Should have a snapshot id"); + + const breakdown = getState().censusDisplay.breakdown; + ok(breakdown, "Should have a breakdown"); + + dispatch(fetchIndividuals(heapWorker, snapshotId, breakdown, + reportLeafIndex)); + + for (let state of EXPECTED_INDIVIDUAL_STATES) { + yield waitUntilState(store, s => { + return s.view.state === viewState.INDIVIDUALS && + s.individuals && + s.individuals.state === state; + }); + ok(true, `Reached state = ${state}`); + } + + ok(getState().individuals, "Should have individuals state"); + ok(getState().individuals.nodes, "Should have individuals nodes"); + ok(getState().individuals.nodes.length > 0, + "Should have a positive number of nodes"); + + dispatch(clearSnapshots(heapWorker)); + + equal(getState().view.state, viewState.CENSUS, + "Went back to census view"); + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_pop_view_01.js b/devtools/client/memory/test/unit/test_pop_view_01.js new file mode 100644 index 000000000..9e6a17095 --- /dev/null +++ b/devtools/client/memory/test/unit/test_pop_view_01.js @@ -0,0 +1,81 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +// Test popping views from each intermediate individuals model state. + +const { + censusState, + viewState, + individualsState, +} = require("devtools/client/memory/constants"); +const { + fetchIndividuals, + takeSnapshotAndCensus, +} = require("devtools/client/memory/actions/snapshot"); +const { + changeView, + popViewAndRefresh, +} = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +const TEST_STATES = [ + individualsState.COMPUTING_DOMINATOR_TREE, + individualsState.FETCHING, + individualsState.FETCHED, +]; + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + const { getState, dispatch } = store; + + equal(getState().individuals, null, + "no individuals state by default"); + + dispatch(changeView(viewState.CENSUS)); + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + const root = getState().snapshots[0].census.report; + ok(root, "Should have a census"); + + const reportLeafIndex = findReportLeafIndex(root); + ok(reportLeafIndex, "Should get a reportLeafIndex"); + + const snapshotId = getState().snapshots[0].id; + ok(snapshotId, "Should have a snapshot id"); + + const breakdown = getState().snapshots[0].census.display.breakdown; + ok(breakdown, "Should have a breakdown"); + + for (let state of TEST_STATES) { + dumpn(`Testing popping back to the old view from state = ${state}`); + + dispatch(fetchIndividuals(heapWorker, snapshotId, breakdown, + reportLeafIndex)); + + // Wait for the expected test state. + yield waitUntilState(store, s => { + return s.view.state === viewState.INDIVIDUALS && + s.individuals && + s.individuals.state === state; + }); + ok(true, `Reached state = ${state}`); + + // Pop back to the CENSUS state. + dispatch(popViewAndRefresh(heapWorker)); + yield waitUntilState(store, s => { + return s.view.state === viewState.CENSUS; + }); + ok(!getState().individuals, "Should no longer have individuals"); + } + + heapWorker.destroy(); + yield front.detach(); +}); diff --git a/devtools/client/memory/test/unit/test_tree-map-01.js b/devtools/client/memory/test/unit/test_tree-map-01.js new file mode 100644 index 000000000..15d9a765a --- /dev/null +++ b/devtools/client/memory/test/unit/test_tree-map-01.js @@ -0,0 +1,57 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const { drawBox } = require("devtools/client/memory/components/tree-map/draw"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let fillRectValues, strokeRectValues; + let ctx = { + fillRect: (...args) => fillRectValues = args, + strokeRect: (...args) => strokeRectValues = args + }; + let node = { + x: 20, + y: 30, + dx: 50, + dy: 70, + type: "other", + depth: 2 + }; + let padding = [10, 10]; + let borderWidth = () => 1; + let dragZoom = { + offsetX: 0, + offsetY: 0, + zoom: 0 + }; + drawBox(ctx, node, borderWidth, dragZoom, padding); + ok(true, JSON.stringify([ctx, fillRectValues, strokeRectValues])); + equal(ctx.fillStyle, "hsl(210,60%,70%)", "The fillStyle is set"); + equal(ctx.strokeStyle, "hsl(210,60%,35%)", "The strokeStyle is set"); + equal(ctx.lineWidth, 1, "The lineWidth is set"); + deepEqual(fillRectValues, [10.5, 20.5, 49, 69], "Draws a filled rectangle"); + deepEqual(strokeRectValues, [10.5, 20.5, 49, 69], "Draws a stroked rectangle"); + + + dragZoom.zoom = 0.5; + + drawBox(ctx, node, borderWidth, dragZoom, padding); + ok(true, JSON.stringify([ctx, fillRectValues, strokeRectValues])); + deepEqual(fillRectValues, [15.5, 30.5, 74, 104], + "Draws a zoomed filled rectangle"); + deepEqual(strokeRectValues, [15.5, 30.5, 74, 104], + "Draws a zoomed stroked rectangle"); + + dragZoom.offsetX = 110; + dragZoom.offsetY = 130; + + drawBox(ctx, node, borderWidth, dragZoom, padding); + deepEqual(fillRectValues, [-94.5, -99.5, 74, 104], + "Draws a zoomed and offset filled rectangle"); + deepEqual(strokeRectValues, [-94.5, -99.5, 74, 104], + "Draws a zoomed and offset stroked rectangle"); +}); diff --git a/devtools/client/memory/test/unit/test_tree-map-02.js b/devtools/client/memory/test/unit/test_tree-map-02.js new file mode 100644 index 000000000..4f7200f0a --- /dev/null +++ b/devtools/client/memory/test/unit/test_tree-map-02.js @@ -0,0 +1,81 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { drawText } = require("devtools/client/memory/components/tree-map/draw"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + // Mock out the Canvas2dContext + let ctx = { + fillText: (...args) => fillTextValues.push(args), + measureText: (text) => { + let width = text ? text.length * 10 : 0; + return { width }; + } + }; + let node = { + x: 20, + y: 30, + dx: 500, + dy: 70, + name: "Example Node", + totalBytes: 1200, + totalCount: 100 + }; + let ratio = 0; + let borderWidth = () => 1; + let dragZoom = { + offsetX: 0, + offsetY: 0, + zoom: 0 + }; + let fillTextValues = []; + let padding = [10, 10]; + + drawText(ctx, node, borderWidth, ratio, dragZoom, padding); + deepEqual(fillTextValues[0], ["Example Node", 11.5, 21.5], + "Fills in the full node name"); + deepEqual(fillTextValues[1], ["1KiB 100 count", 141.5, 21.5], + "Includes the full byte and count information"); + + fillTextValues = []; + node.dx = 250; + drawText(ctx, node, borderWidth, ratio, dragZoom, padding); + + deepEqual(fillTextValues[0], ["Example Node", 11.5, 21.5], + "Fills in the full node name"); + deepEqual(fillTextValues[1], undefined, + "Drops off the byte and count information if not enough room"); + + fillTextValues = []; + node.dx = 100; + drawText(ctx, node, borderWidth, ratio, dragZoom, padding); + + deepEqual(fillTextValues[0], ["Exampl...", 11.5, 21.5], + "Cuts the name with ellipsis"); + deepEqual(fillTextValues[1], undefined, + "Drops off the byte and count information if not enough room"); + + fillTextValues = []; + node.dx = 40; + drawText(ctx, node, borderWidth, ratio, dragZoom, padding); + + deepEqual(fillTextValues[0], ["...", 11.5, 21.5], + "Shows only ellipsis when smaller"); + deepEqual(fillTextValues[1], undefined, + "Drops off the byte and count information if not enough room"); + + fillTextValues = []; + node.dx = 20; + drawText(ctx, node, borderWidth, ratio, dragZoom, padding); + + deepEqual(fillTextValues[0], undefined, + "Draw nothing when not enough room"); + deepEqual(fillTextValues[1], undefined, + "Drops off the byte and count information if not enough room"); +}); diff --git a/devtools/client/memory/test/unit/test_utils-get-snapshot-totals.js b/devtools/client/memory/test/unit/test_utils-get-snapshot-totals.js new file mode 100644 index 000000000..c4560fb07 --- /dev/null +++ b/devtools/client/memory/test/unit/test_utils-get-snapshot-totals.js @@ -0,0 +1,72 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +/** + * Tests that we use the correct snapshot aggregate value + * in `utils.getSnapshotTotals(snapshot)` + */ + +const { censusDisplays, snapshotState: states, viewState, censusState } = require("devtools/client/memory/constants"); +const { getSnapshotTotals } = require("devtools/client/memory/utils"); +const { takeSnapshotAndCensus } = require("devtools/client/memory/actions/snapshot"); +const { setCensusDisplayAndRefresh } = require("devtools/client/memory/actions/census-display"); +const { changeView } = require("devtools/client/memory/actions/view"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let front = new StubbedMemoryFront(); + let heapWorker = new HeapAnalysesClient(); + yield front.attach(); + let store = Store(); + let { getState, dispatch } = store; + + dispatch(changeView(viewState.CENSUS)); + + yield dispatch(setCensusDisplayAndRefresh(heapWorker, + censusDisplays.allocationStack)); + + dispatch(takeSnapshotAndCensus(front, heapWorker)); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + + ok(!getState().snapshots[0].census.display.inverted, "Snapshot is not inverted"); + + let census = getState().snapshots[0].census; + let result = aggregate(census.report); + let totalBytes = result.bytes; + let totalCount = result.count; + + ok(totalBytes > 0, "counted up bytes in the census"); + ok(totalCount > 0, "counted up count in the census"); + + result = getSnapshotTotals(getState().snapshots[0].census); + equal(totalBytes, result.bytes, "getSnapshotTotals reuslted in correct bytes"); + equal(totalCount, result.count, "getSnapshotTotals reuslted in correct count"); + + dispatch(setCensusDisplayAndRefresh(heapWorker, + censusDisplays.invertedAllocationStack)); + + yield waitUntilCensusState(store, s => s.census, [censusState.SAVING]); + yield waitUntilCensusState(store, s => s.census, [censusState.SAVED]); + ok(getState().snapshots[0].census.display.inverted, "Snapshot is inverted"); + + result = getSnapshotTotals(getState().snapshots[0].census); + equal(totalBytes, result.bytes, + "getSnapshotTotals reuslted in correct bytes when inverted"); + equal(totalCount, result.count, + "getSnapshotTotals reuslted in correct count when inverted"); +}); + +function aggregate(report) { + let totalBytes = report.bytes; + let totalCount = report.count; + for (let child of (report.children || [])) { + let { bytes, count } = aggregate(child); + totalBytes += bytes; + totalCount += count; + } + return { bytes: totalBytes, count: totalCount }; +} diff --git a/devtools/client/memory/test/unit/test_utils.js b/devtools/client/memory/test/unit/test_utils.js new file mode 100644 index 000000000..f6deddfc9 --- /dev/null +++ b/devtools/client/memory/test/unit/test_utils.js @@ -0,0 +1,70 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +"use strict"; + +/** + * Tests the task creator `takeSnapshotAndCensus()` for the whole flow of + * taking a snapshot, and its sub-actions. Tests the formatNumber and + * formatPercent methods. + */ + +let utils = require("devtools/client/memory/utils"); +let { snapshotState: states, viewState } = require("devtools/client/memory/constants"); +let { Preferences } = require("resource://gre/modules/Preferences.jsm"); + +function run_test() { + run_next_test(); +} + +add_task(function* () { + let s1 = utils.createSnapshot({ view: { state: viewState.CENSUS } }); + let s2 = utils.createSnapshot({ view: { state: viewState.CENSUS } }); + equal(s1.state, states.SAVING, "utils.createSnapshot() creates snapshot in saving state"); + ok(s1.id !== s2.id, "utils.createSnapshot() creates snapshot with unique ids"); + + let custom = { by: "internalType", then: { by: "count", bytes: true }}; + Preferences.set("devtools.memory.custom-census-displays", JSON.stringify({ "My Display": custom })); + + equal(utils.getCustomCensusDisplays()["My Display"].by, custom.by, + "utils.getCustomCensusDisplays() returns custom displays"); + + ok(true, "test formatNumber util functions"); + equal(utils.formatNumber(12), "12", "formatNumber returns 12 for 12"); + + equal(utils.formatNumber(0), "0", "formatNumber returns 0 for 0"); + equal(utils.formatNumber(-0), "0", "formatNumber returns 0 for -0"); + equal(utils.formatNumber(+0), "0", "formatNumber returns 0 for +0"); + + equal(utils.formatNumber(1234567), "1 234 567", + "formatNumber adds a space every 3rd digit"); + equal(utils.formatNumber(12345678), "12 345 678", + "formatNumber adds a space every 3rd digit"); + equal(utils.formatNumber(123456789), "123 456 789", + "formatNumber adds a space every 3rd digit"); + + equal(utils.formatNumber(12, true), "+12", + "formatNumber can display number sign"); + equal(utils.formatNumber(-12, true), "-12", + "formatNumber can display number sign (negative)"); + + ok(true, "test formatPercent util functions"); + equal(utils.formatPercent(12), "12%", "formatPercent returns 12% for 12"); + equal(utils.formatPercent(12345), "12 345%", + "formatPercent returns 12 345% for 12345"); + + equal(utils.formatAbbreviatedBytes(12), "12B", "Formats bytes"); + equal(utils.formatAbbreviatedBytes(12345), "12KiB", "Formats kilobytes"); + equal(utils.formatAbbreviatedBytes(12345678), "11MiB", "Formats megabytes"); + equal(utils.formatAbbreviatedBytes(12345678912), "11GiB", "Formats gigabytes"); + + equal(utils.hslToStyle(0.5, 0.6, 0.7), + "hsl(180,60%,70%)", "hslToStyle converts an array to a style string"); + equal(utils.hslToStyle(0, 0, 0), + "hsl(0,0%,0%)", "hslToStyle converts an array to a style string"); + equal(utils.hslToStyle(1, 1, 1), + "hsl(360,100%,100%)", "hslToStyle converts an array to a style string"); + + equal(utils.lerp(5, 7, 0), 5, "lerp return first number for 0"); + equal(utils.lerp(5, 7, 1), 7, "lerp return second number for 1"); + equal(utils.lerp(5, 7, 0.5), 6, "lerp interpolates the numbers for 0.5"); +}); diff --git a/devtools/client/memory/test/unit/xpcshell.ini b/devtools/client/memory/test/unit/xpcshell.ini new file mode 100644 index 000000000..dade269c3 --- /dev/null +++ b/devtools/client/memory/test/unit/xpcshell.ini @@ -0,0 +1,56 @@ +[DEFAULT] +tags = devtools devtools-memory +head = head.js ../../../framework/test/shared-redux-head.js +tail = +firefox-appdir = browser +skip-if = toolkit == 'android' + +[test_action_diffing_01.js] +[test_action_diffing_02.js] +[test_action_diffing_03.js] +[test_action_diffing_04.js] +[test_action_diffing_05.js] +[test_action-clear-snapshots_01.js] +[test_action-clear-snapshots_02.js] +[test_action-clear-snapshots_03.js] +[test_action-clear-snapshots_04.js] +[test_action-clear-snapshots_05.js] +[test_action-clear-snapshots_06.js] +[test_action-export-snapshot.js] +[test_action-filter-01.js] +[test_action-filter-02.js] +[test_action-filter-03.js] +[test_action-import-snapshot-and-census.js] +[test_action-import-snapshot-dominator-tree.js] +[test_action-select-snapshot.js] +[test_action-set-display.js] +[test_action-set-display-and-refresh-01.js] +[test_action-set-display-and-refresh-02.js] +[test_action-take-census.js] +[test_action-take-snapshot.js] +[test_action-take-snapshot-and-census.js] +[test_action-toggle-inverted.js] +[test_action-toggle-inverted-and-refresh-01.js] +[test_action-toggle-inverted-and-refresh-02.js] +[test_action-toggle-recording-allocations.js] +[test_dominator_trees_01.js] +[test_dominator_trees_02.js] +[test_dominator_trees_03.js] +[test_dominator_trees_04.js] +[test_dominator_trees_05.js] +[test_dominator_trees_06.js] +[test_dominator_trees_07.js] +[test_dominator_trees_08.js] +[test_dominator_trees_09.js] +[test_dominator_trees_10.js] +[test_individuals_01.js] +[test_individuals_02.js] +[test_individuals_03.js] +[test_individuals_04.js] +[test_individuals_05.js] +[test_individuals_06.js] +[test_pop_view_01.js] +[test_tree-map-01.js] +[test_tree-map-02.js] +[test_utils.js] +[test_utils-get-snapshot-totals.js] |