423 lines
17 KiB
JavaScript
423 lines
17 KiB
JavaScript
// Copyright (C) 2026 Zaher Salman
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
const assert = require("assert");
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const vm = require("vm");
|
|
|
|
const repoRoot = path.resolve(__dirname, "..");
|
|
|
|
function loadRootLibrary() {
|
|
const code = fs.readFileSync(path.join(repoRoot, "muSRFitRoot.js"), "utf8");
|
|
const sandbox = {
|
|
console: console,
|
|
window: {},
|
|
document: {},
|
|
setTimeout: setTimeout,
|
|
clearTimeout: clearTimeout,
|
|
Promise: Promise,
|
|
Error: Error
|
|
};
|
|
sandbox.global = sandbox;
|
|
vm.runInNewContext(code, sandbox, { filename: "muSRFitRoot.js" });
|
|
return sandbox;
|
|
}
|
|
|
|
function testCleanLegendLabels() {
|
|
const lib = loadRootLibrary();
|
|
|
|
assert.strictEqual(
|
|
lib.cleanMusrfitRootLegendLabel("514,h:1/2,T=5.00K,B=100.00G,E=12.00keV,LEM"),
|
|
"T=5.00 K, B=100.00 G, E=12.00 keV"
|
|
);
|
|
assert.strictEqual(
|
|
lib.cleanMusrfitRootLegendLabel("515,h:1/2,T=??,B=25.00G,E=??,GPS"),
|
|
"B=25.00 G"
|
|
);
|
|
assert.strictEqual(
|
|
lib.cleanMusrfitRootLegendLabel("516,h:1/2,T0=4.20K,T1=4.35K,B=??,E=??,LEM"),
|
|
"T0=4.20 K, T1=4.35 K"
|
|
);
|
|
assert.strictEqual(
|
|
lib.cleanMusrfitRootLegendLabel("++517,h:1/2,T=??,B=??,E=??,GPS"),
|
|
"517"
|
|
);
|
|
}
|
|
|
|
function testCleanCanvasLayout() {
|
|
const lib = loadRootLibrary();
|
|
const title = {
|
|
_typename: "TPaveText",
|
|
fX1NDC: 0.0,
|
|
fY1NDC: 0.95,
|
|
fX2NDC: 1.0,
|
|
fY2NDC: 1.0,
|
|
fTextFont: 42,
|
|
fLines: {
|
|
arr: [{ _typename: "TText", fTextFont: 42 }]
|
|
}
|
|
};
|
|
const frame = {
|
|
_typename: "TH1F",
|
|
fXaxis: {
|
|
_typename: "TAxis",
|
|
fBits: 0,
|
|
fLabelFont: 42,
|
|
fTitleFont: 42,
|
|
fLabelSize: 0.03,
|
|
fTitleSize: 0.04
|
|
},
|
|
fYaxis: {
|
|
_typename: "TAxis",
|
|
fBits: 0,
|
|
fLabelFont: 42,
|
|
fTitleFont: 42,
|
|
fLabelSize: 0.03,
|
|
fTitleSize: 0.04
|
|
}
|
|
};
|
|
const dataPad = {
|
|
_typename: "TPad",
|
|
fName: "dataTheoryPad",
|
|
fXlowNDC: 0.0,
|
|
fYlowNDC: 0.1,
|
|
fWNDC: 0.75,
|
|
fHNDC: 0.85,
|
|
fAbsXlowNDC: 0.0,
|
|
fAbsYlowNDC: 0.1,
|
|
fAbsWNDC: 0.75,
|
|
fAbsHNDC: 0.85,
|
|
fPrimitives: {
|
|
arr: [frame]
|
|
}
|
|
};
|
|
const parameterPad = {
|
|
_typename: "TPaveText",
|
|
fX1NDC: 0.75,
|
|
fY1NDC: 0.5,
|
|
fX2NDC: 1.0,
|
|
fY2NDC: 0.95
|
|
};
|
|
const theoryPad = {
|
|
_typename: "TPaveText",
|
|
fX1NDC: 0.75,
|
|
fY1NDC: 0.1,
|
|
fX2NDC: 1.0,
|
|
fY2NDC: 0.5
|
|
};
|
|
const infoLegend = {
|
|
_typename: "TLegend",
|
|
fX1NDC: 0.0,
|
|
fY1NDC: 0.0,
|
|
fX2NDC: 1.0,
|
|
fY2NDC: 0.1,
|
|
fHeader: "musrfit: date, chisq = 1, NDF = 1",
|
|
fTextFont: 42,
|
|
fPrimitives: {
|
|
arr: [
|
|
{ _typename: "TLegendEntry", fLabel: "musrfit: date, chisq = 1", fOption: "h" },
|
|
{ _typename: "TLegendEntry", fLabel: "514,h:1/2,T=5.00K,B=100.00G,E=12.00keV,LEM", fOption: "p" },
|
|
{ _typename: "TLegendEntry", fLabel: "515,h:1/2,T=??,B=25.00G,E=??,GPS", fOption: "p" }
|
|
],
|
|
opt: ["", "p", "p"]
|
|
}
|
|
};
|
|
const canvas = {
|
|
_typename: "TCanvas",
|
|
fPrimitives: {
|
|
arr: [title, dataPad, parameterPad, theoryPad, infoLegend],
|
|
opt: ["", "", "", "", ""]
|
|
}
|
|
};
|
|
|
|
lib.cleanMusrfitRootCanvas(canvas);
|
|
|
|
assert.strictEqual(canvas.fPrimitives.arr.length, 3);
|
|
assert.strictEqual(canvas.fPrimitives.opt.length, 3);
|
|
assert.strictEqual(canvas.fPrimitives.arr[0], title);
|
|
assert.strictEqual(canvas.fPrimitives.arr[1], dataPad);
|
|
assert.strictEqual(canvas.fPrimitives.arr[2], infoLegend);
|
|
// Clean mode keeps the original width but uses the space freed by the
|
|
// removed bottom legend to stretch the data pad vertically.
|
|
assert.strictEqual(dataPad.fWNDC, 0.75);
|
|
assert.strictEqual(dataPad.fAbsWNDC, 0.75);
|
|
assert.strictEqual(dataPad.fYlowNDC, 0.0);
|
|
assert.strictEqual(dataPad.fHNDC, 0.95);
|
|
assert.strictEqual(dataPad.fAbsYlowNDC, 0.0);
|
|
assert.strictEqual(dataPad.fAbsHNDC, 0.95);
|
|
assert.strictEqual(infoLegend.fX1NDC, 0.76);
|
|
assert.strictEqual(infoLegend.fX2NDC, 0.99);
|
|
assert.strictEqual(infoLegend.fY2NDC, 0.92);
|
|
assert.ok(infoLegend.fY1NDC >= 0.11);
|
|
assert.strictEqual(infoLegend.fNColumns, 1);
|
|
assert.strictEqual(infoLegend.fTextSize, 0.028);
|
|
assert.strictEqual(infoLegend.fHeader, "");
|
|
assert.strictEqual(infoLegend.fPrimitives.arr.length, 4);
|
|
assert.strictEqual(infoLegend.fPrimitives.opt.length, 4);
|
|
assert.deepStrictEqual(
|
|
Array.from(infoLegend.fPrimitives.arr, function(entry) { return entry.fLabel; }),
|
|
["T=5.00 K", "B=100.00 G", "E=12.00 keV", "B=25.00 G"]
|
|
);
|
|
assert.deepStrictEqual(Array.from(infoLegend.fPrimitives.opt), ["p", "", "", "p"]);
|
|
assert.strictEqual(infoLegend.fPrimitives.arr[0].fOption, "p");
|
|
assert.strictEqual(infoLegend.fPrimitives.arr[1].fOption, "");
|
|
assert.strictEqual(infoLegend.fPrimitives.arr[2].fOption, "");
|
|
assert.strictEqual(infoLegend.fPrimitives.arr[3].fOption, "p");
|
|
|
|
// Clean mode uses a LaTeX-friendly serif font throughout the retained
|
|
// annotations and gives centered axis titles a clear size hierarchy.
|
|
assert.strictEqual(title.fTextFont, 132);
|
|
assert.strictEqual(title.fLines.arr[0].fTextFont, 132);
|
|
assert.strictEqual(infoLegend.fTextFont, 132);
|
|
[frame.fXaxis, frame.fYaxis].forEach(function(axis) {
|
|
assert.strictEqual(axis.fLabelFont, 132);
|
|
assert.strictEqual(axis.fTitleFont, 132);
|
|
assert.strictEqual(axis.fLabelSize, 0.034);
|
|
assert.strictEqual(axis.fTitleSize, 0.040);
|
|
assert.ok((axis.fBits & (1 << 12)) !== 0);
|
|
});
|
|
}
|
|
|
|
function testCrowdedLegendFallsBackAndShrinks() {
|
|
const lib = loadRootLibrary();
|
|
const legend = {
|
|
_typename: "TLegend",
|
|
fHeader: "musrfit: date",
|
|
fPrimitives: {
|
|
arr: [{ _typename: "TLegendEntry", fLabel: "musrfit: date", fOption: "h" }],
|
|
opt: [""]
|
|
}
|
|
};
|
|
|
|
for (let run = 0; run < 20; run++) {
|
|
legend.fPrimitives.arr.push({
|
|
_typename: "TLegendEntry",
|
|
fLabel: String(500 + run) + ",h:1/2,T=5.00K,B=100.00G,E=12.00keV,LEM",
|
|
fOption: "p"
|
|
});
|
|
legend.fPrimitives.opt.push("p");
|
|
}
|
|
|
|
lib.cleanMusrfitRootInfoLegend(legend);
|
|
lib.positionMusrfitRootInfoLegend(legend);
|
|
|
|
// Sixty separate T/B/E rows would exceed the side column, so crowded
|
|
// legends return to one metadata line per data set.
|
|
assert.strictEqual(legend.fPrimitives.arr.length, 20);
|
|
assert.strictEqual(
|
|
legend.fPrimitives.arr[0].fLabel,
|
|
"T=5.00 K, B=100.00 G, E=12.00 keV"
|
|
);
|
|
assert.strictEqual(legend.fY2NDC, 0.92);
|
|
assert.ok(Math.abs(legend.fY1NDC - 0.12) < 1e-12);
|
|
|
|
// The compact metadata line is also much wider than the side legend. The
|
|
// final font therefore has to satisfy both the vertical and horizontal
|
|
// constraints, not just the row-count constraint.
|
|
assert.ok(legend.fTextSize < 0.012);
|
|
|
|
const legendWidth = legend.fX2NDC - legend.fX1NDC;
|
|
const textWidth = legendWidth * 0.75 - 0.01;
|
|
const estimatedLabelWidth = legend.fPrimitives.arr[0].fLabel.length
|
|
* legend.fTextSize * 0.52;
|
|
assert.ok(estimatedLabelWidth <= textWidth + 1e-12);
|
|
}
|
|
|
|
function testCleanViewIsDefaultAndToggleExists() {
|
|
const code = fs.readFileSync(path.join(repoRoot, "muSRFitRoot.js"), "utf8");
|
|
assert.match(code, /viewMode = "clean"/);
|
|
assert.match(code, /let rootViewMode = "clean"/);
|
|
assert.match(code, /shortcut === "c"/);
|
|
assert.match(code, /rootViewMode === "clean" \? "original" : "clean"/);
|
|
|
|
// Hover details belong to the original ROOT view. Clean mode should keep
|
|
// the canvas interactive while disabling only JSROOT's verbose tooltip.
|
|
assert.match(code, /setTooltipAllowed\(viewMode !== "clean"\)/);
|
|
}
|
|
|
|
// The plot window must expose its commands on a touch screen, where the musrview
|
|
// keyboard shortcuts (f/c/u/q) are unreachable. A hamburger button on the title
|
|
// bar opens a dropdown of plot actions that invoke the same handlers.
|
|
function testTouchActionMenu() {
|
|
const code = fs.readFileSync(path.join(repoRoot, "muSRFitRoot.js"), "utf8");
|
|
|
|
// Hamburger button created and placed first in the title bar.
|
|
assert.match(code, /plotMenuButton.innerHTML = "☰"/);
|
|
assert.match(code, /plotHeader\.appendChild\(plotMenuButton\)/);
|
|
|
|
// The dropdown exists and defaults to hidden; the hamburger toggles it.
|
|
assert.match(code, /let plotActionMenu = document\.createElement\("div"\)/);
|
|
assert.match(code, /plotActionMenu\.hidden = true/);
|
|
assert.match(code, /function toggleRootPlotActionMenu/);
|
|
|
|
// Each musrview shortcut is mirrored by a menu action wired to the shared
|
|
// handler: FFT (f), clean/original (c), reset (u).
|
|
assert.match(code, /rootPlotActionButton\("FFT"/);
|
|
assert.match(code, /"Clean \/ Original view"/);
|
|
assert.match(code, /"Reset view"/);
|
|
|
|
// FFT is only meaningful when the plot knows its source .msr, matching the
|
|
// keyboard guard on the "f" shortcut.
|
|
assert.match(code, /if \(plotContext\.msrPath\)\s*\{\s*\/\/[^]*?fftActionButton = rootPlotActionButton/);
|
|
assert.match(code, /shortcut === "f"/);
|
|
|
|
const css = fs.readFileSync(path.join(repoRoot, "ZGUI.css"), "utf8");
|
|
// Touch-friendly hit targets and a label that appears only on wider screens.
|
|
assert.match(css, /\.web-plot-menu-button/);
|
|
assert.match(css, /\.web-plot-action-menu/);
|
|
assert.match(css, /\.web-plot-action/);
|
|
assert.match(css, /min-height: 44px/);
|
|
|
|
// The action menu must not begin a window drag and must close on outside tap.
|
|
assert.match(code, /plotMenuButton\.contains\(event\.target\)/);
|
|
assert.match(code, /!plotActionMenu\.contains\(event\.target\)/);
|
|
}
|
|
|
|
// A ROOT pane can hang on "Loading ROOT canvas..." when JSROOT's openFile /
|
|
// readObject / draw never settles (e.g. a ranged fetch against a server that
|
|
// never answers). Every await is time-bound so the pane degrades to a visible
|
|
// error, and the error carries a Retry button for recovery.
|
|
function testLoadTimeout() {
|
|
const lib = loadRootLibrary();
|
|
|
|
// A promise that wins the race resolves through the wrapper unchanged.
|
|
return lib.withMusrfitRootTimeout(Promise.resolve(42), "step", "http://u/r.root")
|
|
.then(function(value) {
|
|
assert.strictEqual(value, 42, "resolved promise passes through");
|
|
})
|
|
.then(function() {
|
|
// A promise that never settles must reject with a TimeoutError that
|
|
// names the step and the URL so the stuck pane becomes diagnosable.
|
|
lib.window.MusrfitRootFetchTimeoutMs = 30;
|
|
return lib.withMusrfitRootTimeout(
|
|
new Promise(() => {}), "Opening ROOT file", "http://h/x.root");
|
|
})
|
|
.then(
|
|
() => Promise.reject(new Error("expected the stuck promise to time out")),
|
|
(error) => {
|
|
assert.strictEqual(error.name, "TimeoutError");
|
|
assert.match(String(error.message), /Opening ROOT file/);
|
|
assert.match(String(error.message), /http:\/\/h\/x\.root/);
|
|
}
|
|
);
|
|
}
|
|
|
|
// The three per-pane awaits are each wrapped with the deadline, and a failure
|
|
// renders an inline Retry button instead of a bare message.
|
|
function testLoadTimeoutSource() {
|
|
const code = fs.readFileSync(path.join(repoRoot, "muSRFitRoot.js"), "utf8");
|
|
assert.match(code, /withMusrfitRootTimeout\(\s*jsroot\.openFile/);
|
|
assert.match(code, /withMusrfitRootTimeout\(\s*file\.readObject/);
|
|
assert.match(code, /withMusrfitRootTimeout\(\s*jsroot\.draw/);
|
|
assert.match(code, /withMusrfitRootTimeout\(\s*loadMusrfitJSRoot\(\)/);
|
|
assert.match(code, /status\.appendChild\(retry\)/);
|
|
assert.match(code, /Could not load JSROOT:/);
|
|
const css = fs.readFileSync(path.join(repoRoot, "ZGUI.css"), "utf8");
|
|
assert.match(css, /\.web-root-retry/);
|
|
}
|
|
|
|
// Toggling clean/original starts a fresh render on the same container while the
|
|
// previous one may still be fetching/drawing. A generation token lets the stale
|
|
// render abort instead of drawing into a canvas that a newer render already
|
|
// removed, which previously surfaced as "Could not draw ..." on Firefox.
|
|
function testRenderGenerationGuard() {
|
|
const lib = loadRootLibrary();
|
|
const firstContainer = {};
|
|
const secondContainer = {};
|
|
|
|
// Each render advances the generation for its own container only.
|
|
assert.strictEqual(lib.beginMusrfitRootRender(firstContainer), 1);
|
|
assert.strictEqual(lib.beginMusrfitRootRender(firstContainer), 2);
|
|
assert.strictEqual(lib.beginMusrfitRootRender(secondContainer), 1);
|
|
|
|
// A canvas is stale after the container moves on (a newer render started)
|
|
// or once the canvas is detached from the document.
|
|
let detachedCanvas = {};
|
|
detachedCanvas.isConnected = false;
|
|
assert.ok(lib.musrfitRootRenderIsStale(firstContainer, 1, detachedCanvas));
|
|
assert.strictEqual(
|
|
lib.musrfitRootRenderIsStale(firstContainer, 2, { isConnected: true }),
|
|
false,
|
|
"current generation + attached canvas is not stale"
|
|
);
|
|
// An old render token against the current generation is stale.
|
|
assert.ok(lib.musrfitRootRenderIsStale(firstContainer, 1, { isConnected: true }));
|
|
|
|
// Every render path funnels through the tokenized entrypoint and checks
|
|
// staleness after each await so stale draws never paint a removed canvas.
|
|
const code = fs.readFileSync(path.join(repoRoot, "muSRFitRoot.js"), "utf8");
|
|
assert.match(code, /let renderToken = beginMusrfitRootRender\(container\)/);
|
|
assert.match(code, /musrfitRootRenderIsStale\(container, renderToken, canvas\)/);
|
|
assert.match(code, /musrfitRootRenderIsStale\(container, renderToken, container\)/);
|
|
}
|
|
|
|
// Clean/original/reset redraws reuse a decoded ROOT object instead of re-fetching
|
|
// the file each toggle, which is the slow, flaky path on mobile.
|
|
function testDecodeCache() {
|
|
const lib = loadRootLibrary();
|
|
|
|
// The cache key is stable despite the cache-busting query string on the URL.
|
|
assert.strictEqual(
|
|
lib.musrfitRootCacheKey({ url: "/tmp/job/run_0.root?musrflow_root=abc", item: "fMainCanvas0;1" }),
|
|
"/tmp/job/run_0.root|fMainCanvas0;1"
|
|
);
|
|
|
|
// The deep clone paints identically but is fully independent, so mutating the
|
|
// drawn copy never corrupts the cached pristine original.
|
|
const original = {
|
|
_typename: "TCanvas",
|
|
fName: "c" ,
|
|
fTitle: "run",
|
|
fPrimitives: {
|
|
arr: [ { _typename: "TPad", fName: "p", fX: [1, 2, 3] } ],
|
|
opt: [ "p" ]
|
|
}
|
|
};
|
|
const clone = lib.musrfitRootCloneCanvas(original);
|
|
assert.notStrictEqual(clone, original, "clone is a distinct object");
|
|
// Structural equality (JSON round-trip) avoids cross-realm prototype noise,
|
|
// since the vm sandbox builds its own Object.prototype.
|
|
assert.strictEqual(JSON.stringify(clone), JSON.stringify(original),
|
|
"clone matches the source tree");
|
|
clone.fPrimitives.arr[0].fName = "mutated";
|
|
assert.strictEqual(original.fPrimitives.arr[0].fName, "p",
|
|
"mutating the clone does not affect the source");
|
|
|
|
const code = fs.readFileSync(path.join(repoRoot, "muSRFitRoot.js"), "utf8");
|
|
// renderMusrfitRootPlots accepts a decode cache; clean view draws a clone of
|
|
// the cached pristine copy, preferring JSROOT's own clone to preserve the
|
|
// object prototypes jsroot.draw relies on (TestBit et al).
|
|
assert.match(code, /viewMode = "clean", decodeCache = null/);
|
|
assert.match(code, /drawObject = musrfitRootCloneCanvas\(cached, jsroot\)/);
|
|
assert.match(code, /decodeCache\.set\(cacheKey, fileObject\)/);
|
|
assert.match(code, /if \(jsroot && typeof jsroot\.clone === "function"\)/);
|
|
// Clean/original/reset redraws reuse decoded ROOT objects for the active view.
|
|
// Per-view decode caches keep spectrum/FFT and averaged/non-averaged views
|
|
// independent, since server-side musrview may overwrite same-named ROOT files.
|
|
assert.match(code, /renderMusrfitRootPlots\(plotContainer, currentSpecs, resetVersion, rootViewMode, currentDecodeCache\(\)\)/);
|
|
assert.match(code, /renderMusrfitRootPlots\(plotContainer, currentSpecs, version, rootViewMode, rootDecodeCaches\[key\]\)/);
|
|
assert.match(code, /renderMusrfitRootPlots\(plotContainer, initialSpecs, renderVersion, rootViewMode, currentDecodeCache\(\)\)/);
|
|
assert.match(code, /rootDecodeCaches\[key\] = new Map\(\)/);
|
|
assert.match(code, /function currentDecodeCache\(\)/);
|
|
assert.match(code, /spectrum:n/);
|
|
assert.match(code,
|
|
/catch \(error\)[\s\S]*Could not generate[\s\S]*finally[\s\S]*rootPlotRequestInProgress = false/,
|
|
"failed ROOT transformations report the error and always release the request lock");
|
|
}
|
|
|
|
function runTests() {
|
|
testCleanLegendLabels();
|
|
testCleanCanvasLayout();
|
|
testCrowdedLegendFallsBackAndShrinks();
|
|
testCleanViewIsDefaultAndToggleExists();
|
|
testTouchActionMenu();
|
|
testLoadTimeoutSource();
|
|
testRenderGenerationGuard();
|
|
testDecodeCache();
|
|
testLoadTimeout();
|
|
console.log("ROOT clean-view tests passed.");
|
|
}
|
|
|
|
runTests();
|