[Pkg-javascript-devel] Bug#978299: node-lie: FTBFS: dh_auto_test: error: /bin/sh -ex debian/tests/pkg-js/test returned exit code 2
Lucas Nussbaum
lucas at debian.org
Sat Dec 26 21:54:45 GMT 2020
Source: node-lie
Version: 3.3.0+dfsg-1
Severity: serious
Justification: FTBFS on amd64
Tags: bullseye sid ftbfs
Usertags: ftbfs-20201226 ftbfs-bullseye
Hi,
During a rebuild of all packages in sid, your package failed to build
on amd64.
Relevant part (hopefully):
> dpkg-buildpackage
> -----------------
>
> Command: dpkg-buildpackage -us -uc -sa -rfakeroot
> dpkg-buildpackage: info: source package node-lie
> dpkg-buildpackage: info: source version 3.3.0+dfsg-1
> dpkg-buildpackage: info: source distribution unstable
> dpkg-buildpackage: info: source changed by Xavier Guimard <yadd at debian.org>
> dpkg-source --before-build .
> dpkg-buildpackage: info: host architecture amd64
> debian/rules clean
> dh clean
> dh_auto_clean --buildsystem=nodejs
> rm -rf ./node_modules/.cache
> dh_clean
> dpkg-source -b .
> dpkg-source: info: using source format '3.0 (quilt)'
> dpkg-source: info: building node-lie using existing ./node-lie_3.3.0+dfsg.orig.tar.xz
> dpkg-source: info: building node-lie in node-lie_3.3.0+dfsg-1.debian.tar.xz
> dpkg-source: info: building node-lie in node-lie_3.3.0+dfsg-1.dsc
> debian/rules binary
> dh binary
> dh_update_autotools_config
> dh_autoreconf
> dh_auto_configure --buildsystem=nodejs
> dh_auto_build --buildsystem=nodejs
> dh_auto_build: warning: Max loop command exceed, aborting
> dh_auto_test --buildsystem=nodejs
> mkdir -p node_modules
> ln -s ../debian/tests/test_modules/promises-aplus-tests node_modules/promises-aplus-tests
> ln -s ../. node_modules/lie
> /bin/sh -ex debian/tests/pkg-js/test
> + mocha test/cover.js
>
>
> Lie
> ✓ should work resolving a promise new
> ✓ should throw if you don't pass a function
> ✓ should have a working catch method
> 1) should emit events for unhandled errors
> resolve
> ✓ should work with true
> ✓ should work with false
> ✓ should work with null
> ✓ should work with undefined
> ✓ should work with 0
> ✓ should work with 1
> ✓ should work with ''
> ✓ should work with 'something'
> Promise.all
> ✓ fulfills if passed an empty array
> ✓ fulfills if passed an array of mixed fulfilled promises and values
> ✓ rejects if any passed promise is rejected
> ✓ resolves foreign thenables
> ✓ does not reject twice
> ✓ fulfills when passed an sparse array, giving `undefined` for the omitted values
> ✓ does not modify the input array
> ✓ should reject with a TypeError if given a non-iterable
> Promise.race
> ✓ fulfills if passed an empty array
> ✓ fulfills if passed an array of mixed fulfilled promises and values
> ✓ rejects if firsed resolved promise is rejected
> ✓ resolves if second resolved promise is rejected
> ✓ resolves foreign thenables
> ✓ fulfills when passed an sparse array, giving `undefined` for the omitted values
> ✓ should reject with a TypeError if given a non-iterable
> Promises/A+ Tests
> 2.1.2.1: When fulfilled, a promise: must not transition to any other state.
> 2) should emit events for unhandled errors
> ✓ already-fulfilled (100ms)
> ✓ immediately-fulfilled (101ms)
> ✓ eventually-fulfilled (101ms)
> ✓ trying to fulfill then immediately reject (100ms)
> ✓ trying to fulfill then reject, delayed (101ms)
> ✓ trying to fulfill immediately then reject delayed (100ms)
> 2.1.3.1: When rejected, a promise: must not transition to any other state.
> ✓ already-rejected (100ms)
> ✓ immediately-rejected (101ms)
> ✓ eventually-rejected (100ms)
> ✓ trying to reject then immediately fulfill (101ms)
> ✓ trying to reject then fulfill, delayed (100ms)
> ✓ trying to reject immediately then fulfill delayed (99ms)
> 2.2.1: Both `onFulfilled` and `onRejected` are optional arguments.
> 2.2.1.1: If `onFulfilled` is not a function, it must be ignored.
> applied to a directly-rejected promise
> ✓ `onFulfilled` is `undefined`
> ✓ `onFulfilled` is `null`
> ✓ `onFulfilled` is `false`
> ✓ `onFulfilled` is `5`
> ✓ `onFulfilled` is an object
> applied to a promise rejected and then chained off of
> ✓ `onFulfilled` is `undefined`
> ✓ `onFulfilled` is `null`
> ✓ `onFulfilled` is `false`
> ✓ `onFulfilled` is `5`
> ✓ `onFulfilled` is an object
> 2.2.1.2: If `onRejected` is not a function, it must be ignored.
> applied to a directly-fulfilled promise
> ✓ `onRejected` is `undefined`
> ✓ `onRejected` is `null`
> ✓ `onRejected` is `false`
> ✓ `onRejected` is `5`
> ✓ `onRejected` is an object
> applied to a promise fulfilled and then chained off of
> ✓ `onFulfilled` is `undefined`
> ✓ `onFulfilled` is `null`
> ✓ `onFulfilled` is `false`
> ✓ `onFulfilled` is `5`
> ✓ `onFulfilled` is an object
> 2.2.2: If `onFulfilled` is a function,
> 2.2.2.1: it must be called after `promise` is fulfilled, with `promise`’s fulfillment value as its first argument.
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> 2.2.2.2: it must not be called before `promise` is fulfilled
> ✓ fulfilled after a delay (50ms)
> ✓ never fulfilled (151ms)
> 2.2.2.3: it must not be called more than once.
> ✓ already-fulfilled
> ✓ trying to fulfill a pending promise more than once, immediately
> ✓ trying to fulfill a pending promise more than once, delayed (50ms)
> ✓ trying to fulfill a pending promise more than once, immediately then delayed
> ✓ when multiple `then` calls are made, spaced apart in time (150ms)
> ✓ when `then` is interleaved with fulfillment
> 2.2.3: If `onRejected` is a function,
> 2.2.3.1: it must be called after `promise` is rejected, with `promise`’s rejection reason as its first argument.
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> 2.2.3.2: it must not be called before `promise` is rejected
> ✓ rejected after a delay (50ms)
> ✓ never rejected (151ms)
> 2.2.3.3: it must not be called more than once.
> ✓ already-rejected
> ✓ trying to reject a pending promise more than once, immediately
> ✓ trying to reject a pending promise more than once, delayed (50ms)
> ✓ trying to reject a pending promise more than once, immediately then delayed
> ✓ when multiple `then` calls are made, spaced apart in time (149ms)
> ✓ when `then` is interleaved with rejection
> 2.2.4: `onFulfilled` or `onRejected` must not be called until the execution context stack contains only platform code.
> `then` returns before the promise becomes fulfilled or rejected
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (51ms)
> Clean-stack execution ordering tests (fulfillment case)
> ✓ when `onFulfilled` is added immediately before the promise is fulfilled
> ✓ when `onFulfilled` is added immediately after the promise is fulfilled
> ✓ when one `onFulfilled` is added inside another `onFulfilled`
> ✓ when `onFulfilled` is added inside an `onRejected`
> ✓ when the promise is fulfilled asynchronously
> Clean-stack execution ordering tests (rejection case)
> ✓ when `onRejected` is added immediately before the promise is rejected
> ✓ when `onRejected` is added immediately after the promise is rejected
> ✓ when `onRejected` is added inside an `onFulfilled`
> ✓ when one `onRejected` is added inside another `onRejected`
> ✓ when the promise is rejected asynchronously
> 2.2.5 `onFulfilled` and `onRejected` must be called as functions (i.e. with no `this` value).
> sloppy mode
> ✓ fulfilled
> ✓ rejected
> 2.2.6: `then` may be called multiple times on the same promise.
> 2.2.6.1: If/when `promise` is fulfilled, all respective `onFulfilled` callbacks must execute in the order of their originating calls to `then`.
> multiple boring fulfillment handlers
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> multiple fulfillment handlers, one of which throws
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (51ms)
> results in multiple branching chains with their own fulfillment values
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> `onFulfilled` handlers are called in the original order
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (49ms)
> even when one handler is added inside another handler
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (65ms)
> 2.2.6.2: If/when `promise` is rejected, all respective `onRejected` callbacks must execute in the order of their originating calls to `then`.
> multiple boring rejection handlers
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (51ms)
> multiple rejection handlers, one of which throws
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (51ms)
> results in multiple branching chains with their own fulfillment values
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> `onRejected` handlers are called in the original order
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> even when one handler is added inside another handler
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (67ms)
> 2.2.7: `then` must return a promise: `promise2 = promise1.then(onFulfilled, onRejected)`
> ✓ is a promise
> 2.2.7.1: If either `onFulfilled` or `onRejected` returns a value `x`, run the Promise Resolution Procedure `[[Resolve]](promise2, x)`
> ✓ see separate 3.3 tests
> 2.2.7.2: If either `onFulfilled` or `onRejected` throws an exception `e`, `promise2` must be rejected with `e` as the reason.
> The reason is `undefined`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is `null`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is `false`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is `0`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (51ms)
> The reason is an error
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (51ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is an error without a stack
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is a date
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is an object
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is an always-pending thenable
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is a fulfilled promise
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The reason is a rejected promise
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (51ms)
> 2.2.7.3: If `onFulfilled` is not a function and `promise1` is fulfilled, `promise2` must be fulfilled with the same value.
> `onFulfilled` is `undefined`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> `onFulfilled` is `null`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> `onFulfilled` is `false`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (49ms)
> `onFulfilled` is `5`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> `onFulfilled` is an object
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> `onFulfilled` is an array containing a function
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (51ms)
> 2.2.7.4: If `onRejected` is not a function and `promise1` is rejected, `promise2` must be rejected with the same reason.
> `onRejected` is `undefined`
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> `onRejected` is `null`
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> `onRejected` is `false`
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (51ms)
> `onRejected` is `5`
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> `onRejected` is an object
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> `onRejected` is an array containing a function
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> 2.3.1: If `promise` and `x` refer to the same object, reject `promise` with a `TypeError' as the reason.
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> 2.3.2: If `x` is a promise, adopt its state
> 2.3.2.1: If `x` is pending, `promise` must remain pending until `x` is fulfilled or rejected.
> ✓ via return from a fulfilled promise (101ms)
> ✓ via return from a rejected promise (100ms)
> 2.3.2.2: If/when `x` is fulfilled, fulfill `promise` with the same value.
> `x` is already-fulfilled
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `x` is eventually-fulfilled
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> 2.3.2.3: If/when `x` is rejected, reject `promise` with the same reason.
> `x` is already-rejected
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `x` is eventually-rejected
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> 2.3.3: Otherwise, if `x` is an object or function,
> 2.3.3.1: Let `then` be `x.then`
> `x` is an object with null prototype
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `x` is an object with normal Object.prototype
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `x` is a function
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> 2.3.3.2: If retrieving the property `x.then` results in a thrown exception `e`, reject `promise` with `e` as the reason.
> `e` is `undefined`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is `null`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is `false`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is `0`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is an error
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is an error without a stack
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is a date
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is an object
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is an always-pending thenable
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is a fulfilled promise
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `e` is a rejected promise
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> 2.3.3.3: If `then` is a function, call it with `x` as `this`, first argument `resolvePromise`, and second argument `rejectPromise`
> Calls with `x` as `this` and two function arguments
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> Uses the original value of `then`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> 2.3.3.3.1: If/when `resolvePromise` is called with value `y`, run `[[Resolve]](promise, y)`
> `y` is not a thenable
> `y` is `undefined`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is `null`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is `false`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is `5`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an object
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an array
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable
> `y` is a synchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an eventually-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (49ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is a synchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-rejected one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that immediately throws in `then`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an object with a throwing `then` accessor
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an eventually-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is a thenable for a thenable
> `y` is a synchronously-fulfilled custom thenable for a synchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for an asynchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for a synchronously-fulfilled one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for a thenable that tries to fulfill twice
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for a thenable that fulfills but then throws
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for an already-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for an eventually-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (49ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is a synchronously-fulfilled custom thenable for a synchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for an asynchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for a synchronously-rejected one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for a thenable that immediately throws in `then`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for an object with a throwing `then` accessor
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for an already-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled custom thenable for an eventually-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (49ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an asynchronously-fulfilled custom thenable for a synchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for an asynchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for a synchronously-fulfilled one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for a thenable that tries to fulfill twice
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for a thenable that fulfills but then throws
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for an already-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for an eventually-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an asynchronously-fulfilled custom thenable for a synchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for an asynchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for a synchronously-rejected one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for a thenable that immediately throws in `then`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for an object with a throwing `then` accessor
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for an already-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an asynchronously-fulfilled custom thenable for an eventually-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is a synchronously-fulfilled one-time thenable for a synchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for an asynchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for a synchronously-fulfilled one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for a thenable that tries to fulfill twice
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for a thenable that fulfills but then throws
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for an already-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for an eventually-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (51ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `y` is a synchronously-fulfilled one-time thenable for a synchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for an asynchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for a synchronously-rejected one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for a thenable that immediately throws in `then`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for an object with a throwing `then` accessor
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for an already-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a synchronously-fulfilled one-time thenable for an eventually-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (49ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `y` is a thenable that tries to fulfill twice for a synchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for an asynchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for a synchronously-fulfilled one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for a thenable that tries to fulfill twice
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for a thenable that fulfills but then throws
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for an already-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for an eventually-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is a thenable that tries to fulfill twice for a synchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for an asynchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for a synchronously-rejected one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for a thenable that immediately throws in `then`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for an object with a throwing `then` accessor
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for an already-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that tries to fulfill twice for an eventually-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is a thenable that fulfills but then throws for a synchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for an asynchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for a synchronously-fulfilled one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for a thenable that tries to fulfill twice
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for a thenable that fulfills but then throws
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for an already-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for an eventually-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (51ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `y` is a thenable that fulfills but then throws for a synchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for an asynchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for a synchronously-rejected one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for a thenable that immediately throws in `then`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for an object with a throwing `then` accessor
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for an already-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is a thenable that fulfills but then throws for an eventually-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an already-fulfilled promise for a synchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for an asynchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for a synchronously-fulfilled one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for a thenable that tries to fulfill twice
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for a thenable that fulfills but then throws
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for an already-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for an eventually-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an already-fulfilled promise for a synchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for an asynchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for a synchronously-rejected one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for a thenable that immediately throws in `then`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for an object with a throwing `then` accessor
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for an already-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `y` is an already-fulfilled promise for an eventually-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `y` is an eventually-fulfilled promise for a synchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `y` is an eventually-fulfilled promise for an asynchronously-fulfilled custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (53ms)
> `y` is an eventually-fulfilled promise for a synchronously-fulfilled one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an eventually-fulfilled promise for a thenable that tries to fulfill twice
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (49ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `y` is an eventually-fulfilled promise for a thenable that fulfills but then throws
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (51ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an eventually-fulfilled promise for an already-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (49ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an eventually-fulfilled promise for an eventually-fulfilled promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an eventually-fulfilled promise for a synchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (49ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an eventually-fulfilled promise for an asynchronously-rejected custom thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (53ms)
> `y` is an eventually-fulfilled promise for a synchronously-rejected one-time thenable
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (51ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `y` is an eventually-fulfilled promise for a thenable that immediately throws in `then`
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (49ms)
> ✓ via return from a rejected promise (51ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (52ms)
> `y` is an eventually-fulfilled promise for an object with a throwing `then` accessor
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an eventually-fulfilled promise for an already-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (52ms)
> ✓ via return from a rejected promise (51ms)
> `y` is an eventually-fulfilled promise for an eventually-rejected promise
> `then` calls `resolvePromise` synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `then` calls `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (51ms)
> 2.3.3.3.2: If/when `rejectPromise` is called with reason `r`, reject `promise` with `r`
> `r` is `undefined`
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is `null`
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is `false`
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is `0`
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is an error
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is an error without a stack
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is a date
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is an object
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is an always-pending thenable
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is a fulfilled promise
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `r` is a rejected promise
> `then` calls `rejectPromise` synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` calls `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> 2.3.3.3.3: If both `resolvePromise` and `rejectPromise` are called, or multiple calls to the same argument are made, the first call takes precedence, and any further calls are ignored.
> calling `resolvePromise` then `rejectPromise`, both synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `resolvePromise` synchronously then `rejectPromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `resolvePromise` then `rejectPromise`, both asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `resolvePromise` with an asynchronously-fulfilled promise, then calling `rejectPromise`, both synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> calling `resolvePromise` with an asynchronously-rejected promise, then calling `rejectPromise`, both synchronously
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> calling `rejectPromise` then `resolvePromise`, both synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `rejectPromise` synchronously then `resolvePromise` asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `rejectPromise` then `resolvePromise`, both asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `resolvePromise` twice synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `resolvePromise` twice, first synchronously then asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `resolvePromise` twice, both times asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `resolvePromise` with an asynchronously-fulfilled promise, then calling it again, both times synchronously
> ✓ via return from a fulfilled promise (49ms)
> ✓ via return from a rejected promise (50ms)
> calling `resolvePromise` with an asynchronously-rejected promise, then calling it again, both times synchronously
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (51ms)
> calling `rejectPromise` twice synchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `rejectPromise` twice, first synchronously then asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> calling `rejectPromise` twice, both times asynchronously
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> saving and abusing `resolvePromise` and `rejectPromise`
> ✓ via return from a fulfilled promise (100ms)
> ✓ via return from a rejected promise (101ms)
> 2.3.3.3.4: If calling `then` throws an exception `e`,
> 2.3.3.3.4.1: If `resolvePromise` or `rejectPromise` have been called, ignore it.
> `resolvePromise` was called with a non-thenable
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `resolvePromise` was called with an asynchronously-fulfilled promise
> ✓ via return from a fulfilled promise (50ms)
> ✓ via return from a rejected promise (50ms)
> `resolvePromise` was called with an asynchronously-rejected promise
> ✓ via return from a fulfilled promise (51ms)
> ✓ via return from a rejected promise (50ms)
> `rejectPromise` was called
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `resolvePromise` then `rejectPromise` were called
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `rejectPromise` then `resolvePromise` were called
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> 2.3.3.3.4.2: Otherwise, reject `promise` with `e` as the reason.
> straightforward case
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `resolvePromise` is called asynchronously before the `throw`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `rejectPromise` is called asynchronously before the `throw`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> 2.3.3.4: If `then` is not a function, fulfill promise with `x`
> `then` is `5`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` is an object
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` is an array containing a function
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` is a regular expression
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> `then` is an object inheriting from `Function.prototype`
> ✓ via return from a fulfilled promise
> ✓ via return from a rejected promise
> 2.3.4: If `x` is not an object or function, fulfill `promise` with `x`
> The value is `undefined`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (51ms)
> The value is `null`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The value is `false`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The value is `true`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The value is `0`
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (51ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The value is `true` with `Boolean.prototype` modified to have a `then` method
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (50ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
> The value is `1` with `Number.prototype` modified to have a `then` method
> ✓ already-fulfilled
> ✓ immediately-fulfilled
> ✓ eventually-fulfilled (51ms)
> ✓ already-rejected
> ✓ immediately-rejected
> ✓ eventually-rejected (50ms)
>
> mocha promise sanity check
> ✓ passes with a resolved promise
> ✓ passes with a rejected then resolved promise
> ✓ is the native Promise
>
> onFinally
> no callback
> ✓ from resolved
> ✓ from rejected
> throws an exception
> ✓ from resolved
> ✓ from rejected
> returns a non-promise
> ✓ from resolved
> ✓ from rejected
> returns a pending-forever promise
> ✓ from resolved (100ms)
> ✓ from rejected (101ms)
> returns an immediately-fulfilled promise
> ✓ from resolved
> ✓ from rejected
> returns an immediately-rejected promise
> ✓ from resolved
> ✓ from rejected
> returns a fulfilled-after-a-second promise
> ✓ from resolved (1501ms)
> ✓ from rejected (1501ms)
> returns a rejected-after-a-second promise
> ✓ from resolved (1501ms)
> ✓ from rejected (1501ms)
>
>
> 915 passing (19s)
> 2 failing
>
> 1) Lie
> should emit events for unhandled errors:
> Error: called more then once
> at process.onEvent (test/cover.js:362:16)
> at /<<PKGBUILDDIR>>/lib/index.js:148:19
> at Item.run (/usr/share/nodejs/immediate/lib/index.js:72:12)
> at nextTick (/usr/share/nodejs/immediate/lib/index.js:43:32)
> at processTicksAndRejections (internal/process/task_queues.js:79:11)
>
> 2) Lie
> should emit events for unhandled errors:
> Error: done() called multiple times in test <Lie should emit events for unhandled errors> of file /<<PKGBUILDDIR>>/test/cover.js
> at createMultipleDoneError (/usr/share/nodejs/mocha/lib/errors.js:366:13)
> at multiple (/usr/share/nodejs/mocha/lib/runnable.js:288:24)
> at done (/usr/share/nodejs/mocha/lib/runnable.js:299:14)
> at /usr/share/nodejs/mocha/lib/runnable.js:412:7
> at Timeout._onTimeout (test/cover.js:359:13)
> at listOnTimeout (internal/timers.js:554:17)
> at processTimers (internal/timers.js:497:7)
>
>
>
> dh_auto_test: error: /bin/sh -ex debian/tests/pkg-js/test returned exit code 2
The full build log is available from:
http://qa-logs.debian.net/2020/12/26/node-lie_3.3.0+dfsg-1_unstable.log
A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!
If you reassign this bug to another package, please marking it as 'affects'-ing
this package. See https://www.debian.org/Bugs/server-control#affects
If you fail to reproduce this, please provide a build log and diff it with me
so that we can identify if something relevant changed in the meantime.
About the archive rebuild: The rebuild was done on EC2 VM instances from
Amazon Web Services, using a clean, minimal and up-to-date chroot. Every
failed build was retried once to eliminate random failures.
More information about the Pkg-javascript-devel
mailing list