Quelle  inspect-wrapped-promise.js

load(libdir + "asserts.js");

ignoreUnhandledRejections();

let g = newGlobal({newCompartment: true});
let dbg = new Debugger();
let gw = dbg.addDebuggee(g);

g.promise1 = new Promise(() => {});
g.promise2 = Promise.resolve(42);
g.promise3 = Promise.reject(42);
g.promise4 = new Object();
g.promise5 = Promise.prototype;

let promiseDO1 = gw.getOwnPropertyDescriptor('promise1').value;
let promiseDO2 = gw.getOwnPropertyDescriptor('promise2').value;
let promiseDO3 = gw.getOwnPropertyDescriptor('promise3').value;
let promiseDO4 = gw.getOwnPropertyDescriptor('promise4').value;
let promiseDO5 = gw.getOwnPropertyDescriptor('promise5').value;

assertEq(promiseDO1.isPromise, true);
assertEq(promiseDO2.isPromise, true);
assertEq(promiseDO3.isPromise, true);
assertEq(promiseDO4.isPromise, false);
assertEq(promiseDO5.isPromise, false);

assertEq(promiseDO1.promiseState, "pending");
assertEq(promiseDO2.promiseState, "fulfilled");
assertEq(promiseDO3.promiseState, "rejected");
assertThrowsInstanceOf(function () { promiseDO4.promiseState }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseState }, TypeError);

assertThrowsInstanceOf(function () { promiseDO1.promiseValue }, TypeError);
assertEq(promiseDO2.promiseValue, 42);
assertThrowsInstanceOf(function () { promiseDO3.promiseValue }, TypeError);
assertThrowsInstanceOf(function () { promiseDO4.promiseValue }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseValue }, TypeError);

assertThrowsInstanceOf(function () { promiseDO1.promiseReason }, TypeError);
assertThrowsInstanceOf(function () { promiseDO2.promiseReason }, TypeError);
assertEq(promiseDO3.promiseReason, 42);
assertThrowsInstanceOf(function () { promiseDO4.promiseReason }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseReason }, TypeError);

// Depending on whether async stacks are activated, this can be null, which
// has typeof null.
assertEq(typeof promiseDO1.promiseAllocationSite === "object", true);
assertEq(typeof promiseDO2.promiseAllocationSite === "object", true);
assertEq(typeof promiseDO3.promiseAllocationSite === "object", true);
assertThrowsInstanceOf(function () { promiseDO4.promiseAllocationSite }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseAllocationSite }, TypeError);

// Depending on whether async stacks are activated, this can be null, which
// has typeof null.
assertThrowsInstanceOf(function () { promiseDO1.promiseResolutionSite }, TypeError);
assertEq(typeof promiseDO2.promiseResolutionSite === "object", true);
assertEq(typeof promiseDO3.promiseResolutionSite === "object", true);
assertThrowsInstanceOf(function () { promiseDO4.promiseResolutionSite }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseResolutionSite }, TypeError);

assertEq(promiseDO1.promiseID, 1);
assertEq(promiseDO2.promiseID, 2);
assertEq(promiseDO3.promiseID, 3);
assertThrowsInstanceOf(function () { promiseDO4.promiseID }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseID }, TypeError);

assertEq(typeof promiseDO1.promiseDependentPromises, "object");
assertEq(typeof promiseDO2.promiseDependentPromises, "object");
assertEq(typeof promiseDO3.promiseDependentPromises, "object");
assertThrowsInstanceOf(function () { promiseDO4.promiseDependentPromises }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseDependentPromises }, TypeError);

assertEq(promiseDO1.promiseDependentPromises.length, 0);
assertEq(promiseDO2.promiseDependentPromises.length, 0);
assertEq(promiseDO3.promiseDependentPromises.length, 0);

assertEq(typeof promiseDO1.promiseLifetime, "number");
assertEq(typeof promiseDO2.promiseLifetime, "number");
assertEq(typeof promiseDO3.promiseLifetime, "number");
assertThrowsInstanceOf(function () { promiseDO4.promiseLifetime }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseLifetime }, TypeError);

assertThrowsInstanceOf(function () { promiseDO1.promiseTimeToResolution }, TypeError);
assertEq(typeof promiseDO2.promiseTimeToResolution, "number");
assertEq(typeof promiseDO3.promiseTimeToResolution, "number");
assertThrowsInstanceOf(function () { promiseDO4.promiseTimeToResolution }, TypeError);
assertThrowsInstanceOf(function () { promiseDO5.promiseTimeToResolution }, TypeError);