${escapeHtml(extra)}` : ""}`);
+ }
+ function skip(msg) { state.skip++; setCounts(state.pass, state.fail, state.skip); logLine(`⏭️ ${escapeHtml(msg)}`); }
+
+ // ---------- Request helper ----------
+ function gmRequest(details, { abortAfterMs } = {}) {
+ return new Promise((resolve, reject) => {
+ const t0 = performance.now();
+ const req = GM_xmlhttpRequest({
+ ...details,
+ onload: res => resolve({ kind: "load", res, ms: performance.now() - t0 }),
+ onerror: res => reject ({ kind: "error", res, ms: performance.now() - t0 }),
+ ontimeout: res => reject ({ kind: "timeout", res, ms: performance.now() - t0 }),
+ onabort: res => reject ({ kind: "abort", res, ms: performance.now() - t0 }),
+ onprogress: details.onprogress,
+ });
+ if (abortAfterMs != null) setTimeout(() => { try { req.abort(); } catch (_) {} }, abortAfterMs);
+ });
+ }
+
+ const HB = "https://httpbun.com";
+
+ // ---------- Assertion utils ----------
+ function assertEq(a, b, msg) {
+ if (a !== b) throw new Error(msg ? `${msg}: expected ${b}, got ${a}` : `expected ${b}, got ${a}`);
+ }
+
+ function objectProps(o) {
+ if (!o || typeof o !== "object") return "not an object";
+ let z, oD, zD;
+ try { z = Object.assign({}, o); } catch { return "Object.assign failed"; }
+ if (typeof (z.response ?? "") !== "string") return "non-primitive response value exposed";
+ if (typeof (z.responseText ?? "") !== "string") return "non-primitive responseText value exposed";
+ if (typeof (z.responseXML ?? "") !== "string") return "non-primitive responseXML value exposed";
+ try { oD = JSON.stringify(o); } catch { return "JSON.stringify failed"; }
+ try { zD = JSON.stringify(z); } catch { return "JSON.stringify failed"; }
+ if (oD !== zD) return "Object Props Failed";
+ return "ok";
+ }
+
+ // ---------- Tests ----------
+ const basicTests = [
+ {
+ name: 'GET basic with search params 1',
+ async run(fetch) {
+ const { res } = await gmRequest({ method: "GET", url: `${HB}/get?testing=234&abc=567`, responseType: "json", fetch });
+ assertEq(res.status, 200, "status 200");
+ assertEq(res.response?.args?.testing, "234", "response ok");
+ assertEq(res.response?.args?.abc, "567", "response ok");
+ assertEq(res.response?.url, `${HB}/get?testing=234&abc=567`, "response ok");
+ assertEq(objectProps(res), "ok", "Object Props OK");
+ },
+ },
+ {
+ name: 'GET basic with search params 2',
+ async run(fetch) {
+ const { res } = await gmRequest({ method: "GET", url: `${HB}/get?abc=567&testing=234`, responseType: "json", fetch });
+ assertEq(res.status, 200, "status 200");
+ assertEq(res.response?.args?.testing, "234", "response ok");
+ assertEq(res.response?.args?.abc, "567", "response ok");
+ assertEq(res.response?.url, `${HB}/get?abc=567&testing=234`, "response ok");
+ assertEq(objectProps(res), "ok", "Object Props OK");
+ },
+ },
+ {
+ name: "Redirect handling (finalUrl changes) [default]",
+ async run(fetch) {
+ const target = `${HB}/get?z=92`;
+ const { res } = await gmRequest({ method: "GET", url: `${HB}/redirect-to?url=${encodeURIComponent(target)}`, fetch });
+ assertEq(res.status, 200, "status after redirect is 200");
+ assertEq(res.finalUrl, target, "finalUrl is redirected target");
+ assertEq(objectProps(res), "ok", "Object Props OK");
+ },
+ },
+ {
+ name: "Redirect handling (finalUrl changes) [follow]",
+ async run(fetch) {
+ const target = `${HB}/get?z=94`;
+ const { res } = await gmRequest({ method: "GET", url: `${HB}/redirect-to?url=${encodeURIComponent(target)}`, redirect: "follow", fetch });
+ assertEq(res.status, 200, "status after redirect is 200");
+ assertEq(res.finalUrl, target, "finalUrl is redirected target");
+ assertEq(objectProps(res), "ok", "Object Props OK");
+ },
+ },
+ {
+ name: "Redirect handling (finalUrl changes) [error]",
+ async run(fetch) {
+ try {
+ await Promise.race([
+ gmRequest({ method: "GET", url: `${HB}/redirect-to?url=${encodeURIComponent(`${HB}/get?z=96`)}`, redirect: "error", fetch }),
+ new Promise(resolve => setTimeout(resolve, 4000)),
+ ]);
+ throw new Error("Expected error, got load");
+ } catch (e) {
+ assertEq(e?.kind, "error", "error ok");
+ assertEq(e?.res?.status, 408, "statusCode ok");
+ assertEq(!e?.res?.finalUrl, true, "!finalUrl ok");
+ assertEq(e?.res?.responseHeaders, "", "responseHeaders ok");
+ assertEq(objectProps(e?.res), "ok", "Object Props OK");
+ }
+ },
+ },
+ {
+ name: "Redirect handling (finalUrl changes) [manual]",
+ async run(fetch) {
+ const url = `${HB}/redirect-to?url=${encodeURIComponent(`${HB}/get?z=98`)}`;
+ const { res } = await Promise.race([
+ gmRequest({ method: "GET", url, redirect: "manual", fetch }),
+ new Promise(resolve => setTimeout(resolve, 4000)),
+ ]);
+ assertEq(res?.status, 301, "status is 301");
+ assertEq(res?.finalUrl, url, "finalUrl is original url");
+ assertEq(typeof res?.responseHeaders === "string" && res?.responseHeaders !== "", true, "responseHeaders ok");
+ assertEq(objectProps(res), "ok", "Object Props OK");
+ },
+ },
+ ];
+
+ const tests = [
+ ...basicTests,
+ ...basicTests.map(t => ({ ...t, useFetch: true })),
+ ];
+
+ // ---------- Runner ----------
+ function fmtMs(ms) { return ms < 1000 ? `${ms | 0}ms` : `${(ms / 1000).toFixed(2)}s`; }
+
+ async function runAll() {
+ state.pass = state.fail = state.skip = 0;
+ setCounts(0, 0, 0);
+ logLine(`Starting GM_xmlhttpRequest test suite — ${new Date().toLocaleString()}`);
+
+ for (let i = 0; i < tests.length; i++) {
+ const t = tests[i];
+ const tName = `${t.useFetch ? "[fetch]" : "[xhr]"} ${t.name}`;
+ $status.textContent = `Status: running (${i + 1}/${tests.length}): ${tName}`;
+ logLine(`▶️ ${escapeHtml(tName)}`);
+ const t0 = performance.now();
+ try {
+ await t.run(t.useFetch ? true : false);
+ pass(`• ${tName} (${fmtMs(performance.now() - t0)})`);
+ } catch (e) {
+ console.error(e);
+ const stack = e?.stack ? e.stack.split("\n").slice(0, 4).join("\n") : null;
+ fail(`• ${tName} (${fmtMs(performance.now() - t0)})`, [e?.message, stack].filter(Boolean).join("\n"));
+ }
+ }
+
+ $status.textContent = "Status: done";
+ logLine(`Done. ✅ ${state.pass} ❌ ${state.fail} ⏳ ${state.skip}`);
+ }
+
+ setTimeout(() => {
+ if (!window.__gmxhr_test_autorun__) {
+ window.__gmxhr_test_autorun__ = true;
+ runAll();
+ }
+ }, 600);
+})();
\ No newline at end of file
diff --git a/example/tests/gm_xhr_test.js b/example/tests/gm_xhr_test.js
index fa8cef8ae..2cccdf56a 100644
--- a/example/tests/gm_xhr_test.js
+++ b/example/tests/gm_xhr_test.js
@@ -1,7 +1,7 @@
// ==UserScript==
// @name GM_xmlhttpRequest Exhaustive Test Harness v3
// @namespace tm-gmxhr-test
-// @version 1.2.5
+// @version 1.3.0
// @description Comprehensive in-page tests for GM_xmlhttpRequest: normal, abnormal, and edge cases with clear pass/fail output.
// @author you
// @match *://*/*?GM_XHR_TEST_SC
@@ -85,6 +85,8 @@ const enableTool = true;
return `${a};r=${b1};t=${b2};x=${b3}`;
};
+ const isFirefox = typeof mozInnerScreenX === "number";
+
// ---------- Test Panel ----------
const panel = h(
"div",
@@ -191,6 +193,201 @@ const enableTool = true;
$queue.textContent = items.length ? items.map((t, i) => `${i + 1}. ${t}`).join("\n") : "(none)";
}
+ // ---------- Pretty Stack -----------
+ function prettyStack(errorOrStack, options = {}) {
+ const {
+ stripQuery = true,
+ decode = true,
+ maxUrlLength = 90,
+ dropExtensionUuid = true,
+ pathSegments = 2,
+ indent = " ",
+ minFnWidth = 8,
+ maxFnWidth = 48,
+ minLocWidth = 5,
+ maxLocWidth = 12,
+ maxLines = -1,
+ } = options;
+
+ const rawStack =
+ typeof errorOrStack === "string"
+ ? errorOrStack
+ : errorOrStack && errorOrStack.stack
+ ? errorOrStack.stack
+ : String(errorOrStack);
+
+ const lines = rawStack.split(/\r?\n/).filter(Boolean);
+
+ const frames = lines
+ .filter((line, j) => maxLines > 0 ? j < maxLines : true)
+ .map(parseStackLine)
+ .filter(Boolean)
+ .map(frame => ({
+ ...frame,
+ fn: cleanFunctionName(frame.fn),
+ file: cleanFileName(frame.file, {
+ stripQuery,
+ decode,
+ maxUrlLength,
+ dropExtensionUuid,
+ pathSegments,
+ }),
+ }));
+
+ if (!frames.length) return rawStack;
+
+ const fnWidth = clamp(
+ frames.reduce((max, f) => Math.max(max, f.fn.length), minFnWidth),
+ minFnWidth,
+ maxFnWidth
+ );
+
+ const locWidth = clamp(
+ frames.reduce((max, f) => {
+ return Math.max(max, `${f.line}:${f.col}`.length);
+ }, minLocWidth),
+ minLocWidth,
+ maxLocWidth
+ );
+
+ return frames
+ .map(f => {
+ const fn = padRight(truncateMiddle(f.fn, fnWidth), fnWidth);
+ const loc = padLeft(`${f.line}:${f.col}`, locWidth);
+ return `${indent}${fn} ${loc} ${f.file}`;
+ })
+ .join("\n");
+ }
+
+ function parseStackLine(line) {
+ const s = line.trim();
+
+ // Chrome / V8:
+ // at fn (file:line:col)
+ //
+ // Examples:
+ // at run (https://example.com/app.js:10:5)
+ // at async runAll (https://example.com/app.js:20:9)
+ // at new Foo (https://example.com/app.js:30:11)
+ let m = s.match(/^at\s+(.+?)\s+\((.+):(\d+):(\d+)\)$/);
+ if (m) {
+ return {
+ fn: m[1],
+ file: m[2],
+ line: Number(m[3]),
+ col: Number(m[4]),
+ };
+ }
+
+ // Chrome / V8 anonymous:
+ // at file:line:col
+ m = s.match(/^at\s+(.+):(\d+):(\d+)$/);
+ if (m) {
+ return {
+ fn: "