stack-trace-limit.js

Enable keyboard shortcuts

// |jit-test| --enable-error-stack-trace-limit; skip-if: !Error.stackTraceLimit

load(libdir + "asserts.js");

// This is defined in ErrorObject.h and is the the default value

// for Error.stackTraceLimit.

const MAX_REPORTED_STACK_DEPTH = 128;

assertEq(Error.stackTraceLimit, MAX_REPORTED_STACK_DEPTH);

const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");

assertEq(typeof desc.value, "number");

assertEq(desc.writable, true);

assertEq(desc.enumerable, true);

assertEq(desc.configurable, true);

assertEq(desc.get, undefined);

assertEq(desc.set, undefined);

function rec(a) {

    if (a === MAX_REPORTED_STACK_DEPTH + 10) {

      throw new Error();

    rec(a + 1);

function countFrames(error) {

    return error.stack.split("\n").filter(line => line.length > 0).length;

const obj = {};

Error.stackTraceLimit = obj;

assertEq(Error.stackTraceLimit, obj);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

Error.stackTraceLimit = "not a number";

assertEq(Error.stackTraceLimit, "not a number");

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

Error.stackTraceLimit = NaN;

assertEq(Error.stackTraceLimit, NaN);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

Error.stackTraceLimit = -Infinity;

assertEq(Error.stackTraceLimit, -Infinity);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

Error.stackTraceLimit = true;

assertEq(Error.stackTraceLimit, true);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

Error.stackTraceLimit = false;

assertEq(Error.stackTraceLimit, false);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

const sym = Symbol("hello");

Error.stackTraceLimit = sym;

assertEq(Error.stackTraceLimit, sym);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

const arr = [1, 2, 3];

Error.stackTraceLimit = arr;

assertEq(Error.stackTraceLimit, arr);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

const valObj = { valueOf() { return 5; } };

Error.stackTraceLimit = valObj;

assertEq(Error.stackTraceLimit, valObj);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

Error.stackTraceLimit = undefined;

assertEq(Error.stackTraceLimit, undefined);

try { rec(0); } catch (e) {

  assertEq(typeof e.stack, "undefined");

  assertEq("stack" in e, true);

assertEq(typeof new Error("test").stack, "undefined");

assertEq("stack" in new Error("test"), true);

const captureObj = {};

Error.captureStackTrace(captureObj);

assertEq(typeof captureObj.stack, "undefined");

assertEq("stack" in captureObj, true);

Error.stackTraceLimit = -0;

assertEq(Error.stackTraceLimit, -0);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

Error.stackTraceLimit = 0;

assertEq(Error.stackTraceLimit, 0);

try { rec(0); } catch (e) { assertEq(countFrames(e), 0); }

Error.stackTraceLimit = 3;

assertEq(Error.stackTraceLimit, 3);

try { rec(0); } catch (e) { assertEq(countFrames(e), 3); }

Error.stackTraceLimit = 10;

assertEq(Error.stackTraceLimit, 10);

try { rec(0); } catch (e) { assertEq(countFrames(e), 10); }

Error.stackTraceLimit = 25.9;

assertEq(Error.stackTraceLimit, 25.9);

try { rec(0); } catch (e) { assertEq(countFrames(e), 25); }

Error.stackTraceLimit = MAX_REPORTED_STACK_DEPTH;

assertEq(Error.stackTraceLimit, MAX_REPORTED_STACK_DEPTH);

try { rec(0); } catch (e) { assertEq(countFrames(e), MAX_REPORTED_STACK_DEPTH); }

Error.stackTraceLimit = MAX_REPORTED_STACK_DEPTH + 1;

assertEq(Error.stackTraceLimit, MAX_REPORTED_STACK_DEPTH + 1);

try { rec(0); } catch (e) { assertEq(countFrames(e), MAX_REPORTED_STACK_DEPTH); }

Error.stackTraceLimit = 1e12;

assertEq(Error.stackTraceLimit, 1e12);

try { rec(0); } catch (e) { assertEq(countFrames(e), MAX_REPORTED_STACK_DEPTH); }

Error.stackTraceLimit = Infinity;

assertEq(Error.stackTraceLimit, Infinity);

try { rec(0); } catch (e) { assertEq(countFrames(e), MAX_REPORTED_STACK_DEPTH); }

Error.stackTraceLimit = 3;

function deep(n) {

    if (n === 0) {

        var o = {};

        Error.captureStackTrace(o, caller);

        return o;

    return deep(n - 1);

function caller() { return deep(5); }

assertEq(countFrames(caller()), 1);

// With stackTraceLimit=1 and a constructorOpt that skips the topmost

// JS frame, we must still capture one frame (the global frame).

Error.stackTraceLimit = 1;

function smallLimitCaller() {

    const target = {};

    Error.captureStackTrace(target, smallLimitCaller);

    return target;

assertEq(countFrames(smallLimitCaller()), 1);

delete Error.stackTraceLimit;

assertEq("stackTraceLimit" in Error, false);

try { rec(0); } catch (e) { assertEq(typeof e.stack, "undefined"); }

let getterCalled = false;

Object.defineProperty(Error, "stackTraceLimit", {

    get: () => { getterCalled = true; throw new RangeError("limit error"); },

    enumerable: true, configurable: true

});

assertThrowsInstanceOf(() => Error.stackTraceLimit, RangeError);

assertEq(getterCalled, true);

getterCalled = false;

try { rec(0); } catch (e) { assertEq(countFrames(e), MAX_REPORTED_STACK_DEPTH); }

assertEq(getterCalled, false);

getterCalled = false;

new Error("test");

assertEq(getterCalled, false);

getterCalled = false;

Error.captureStackTrace({});

assertEq(getterCalled, false);

Object.defineProperty(Error, "stackTraceLimit", {

    value: 3, writable: true, enumerable: true, configurable: true

});

// Exercise JSContext::setPendingException's stack capture path with

// non-Error throws across different stackTraceLimit values. The realm

// captures stacks for the first ~50 throws, so these all go through

// CaptureStack with the resolved limit.

Error.stackTraceLimit = undefined;

try { throw "string error"; } catch (e) { assertEq(e, "string error"); }

try { throw 42; } catch (e) { assertEq(e, 42); }

try { throw null; } catch (e) { assertEq(e, null); }

try { throw { value: 1 }; } catch (e) { assertEq(e.value, 1); }

Error.stackTraceLimit = 0;

try { throw "string error"; } catch (e) { assertEq(e, "string error"); }

Error.stackTraceLimit = 5;

try { throw "string error"; } catch (e) { assertEq(e, "string error"); }

Error.stackTraceLimit = 3;

Error = "";

try { rec(0); } catch (e) { assertEq(countFrames(e), 3); }