Your message dated Sun, 27 Dec 2020 07:34:16 +0000
with message-id <[email protected]>
and subject line Bug#978299: fixed in node-lie 3.3.0+dfsg-2
has caused the Debian Bug report #978299,
regarding node-lie: FTBFS: dh_auto_test: error: /bin/sh -ex
debian/tests/pkg-js/test returned exit code 2
to be marked as done.
This means that you claim that the problem has been dealt with.
If this is not the case it is now your responsibility to reopen the
Bug report if necessary, and/or fix the problem forthwith.
(NB: If you are a system administrator and have no idea what this
message is talking about, this may indicate a serious mail system
misconfiguration somewhere. Please contact [email protected]
immediately.)
--
978299: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=978299
Debian Bug Tracking System
Contact [email protected] with problems
--- Begin Message ---
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 <[email protected]>
> 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.
--- End Message ---
--- Begin Message ---
Source: node-lie
Source-Version: 3.3.0+dfsg-2
Done: Xavier Guimard <[email protected]>
We believe that the bug you reported is fixed in the latest version of
node-lie, which is due to be installed in the Debian FTP archive.
A summary of the changes between this version and the previous one is
attached.
Thank you for reporting the bug, which will now be closed. If you
have further comments please address them to [email protected],
and the maintainer will reopen the bug report if appropriate.
Debian distribution maintenance software
pp.
Xavier Guimard <[email protected]> (supplier of updated node-lie package)
(This message was generated automatically at their request; if you
believe that there is a problem with it please contact the archive
administrators by mailing [email protected])
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512
Format: 1.8
Date: Sun, 27 Dec 2020 08:11:24 +0100
Source: node-lie
Architecture: source
Version: 3.3.0+dfsg-2
Distribution: unstable
Urgency: medium
Maintainer: Debian Javascript Maintainers
<[email protected]>
Changed-By: Xavier Guimard <[email protected]>
Closes: 978299
Changes:
node-lie (3.3.0+dfsg-2) unstable; urgency=medium
.
* Team upload
* Fix test for mocha ≥ 8 (Closes: #978299)
Checksums-Sha1:
7753bb4df204e20db7655144c66be1c583baf071 2103 node-lie_3.3.0+dfsg-2.dsc
797c3faf7819caf1b71540d7a50d152a96f010ad 11964
node-lie_3.3.0+dfsg-2.debian.tar.xz
Checksums-Sha256:
23440dd9f5abb477e80b62d7956ac0ff09a5cff3937b68d010fd23c4cf8356f7 2103
node-lie_3.3.0+dfsg-2.dsc
f54745bdef21346925e1bb6a13aa38d12b7926b8e40a927662ff876d94763cdb 11964
node-lie_3.3.0+dfsg-2.debian.tar.xz
Files:
f9b06202fbfdaf77189933e31acc6e6a 2103 javascript optional
node-lie_3.3.0+dfsg-2.dsc
20e596395adb3e40c9c0a7eee5bc153a 11964 javascript optional
node-lie_3.3.0+dfsg-2.debian.tar.xz
-----BEGIN PGP SIGNATURE-----
iQIyBAEBCgAdFiEEAN/li4tVV3nRAF7J9tdMp8mZ7ukFAl/oNEgACgkQ9tdMp8mZ
7ulV+Q/4tk2w+YCNkSWynqhXdk+EjO8+rvolJaOlrGJMZXioaB4Yj9uHQUwJCGvO
FAH2382goTZ085tmCzh7UlL3dtwPSVxfA4EEOxncK5ELEKWEmAe1uag8qqS09TI2
gWrEhecaOosdNGLSW1mxqpFU6h88clBpJhkNJ5828pDM6pZQ4DpQIFrqSth+Tbi2
kKf7F/8GGOCenyRXUJCTjdqL9YfrO96jhb6oPlxEi69NpTu4SlN7q4xi5+Kw2oUm
XH4uKGAhlsVJ+Hz+wCKvgEeZEfFOQQSl00uKinKcvw1HRSdfynpgvQtDz1giF3Ox
h4Bu2nHFlBhI5Hmeff9kSY5nnBZ9IOWpSP1CQV94QOJVkBItnBU+lotuMi6Z3kDe
bPWA/pGWFbnH5MI21MQZhOG5s3o8uf7Zk39ee73iHcbxqVPeKJxo+YKt5hWzMk7k
ja/S7csHhHXbNhnAV1YrrFPVzXNSsYeHE5ZC40ac+ep0QuRv9xIQetAK4F5c/Qbc
XfVa37mQ7k3xFqTgApnWa6TjrBnJ+qpTf6VhBWhi3izQ2g0Az9BzjlDJW1/Wv6iM
m2jTjZ+dafUiB4lDPhU03Hrmi5rMtJi7BJDr/X5KBrMprIwrVNOCIvYeIxWnNKcZ
CLlrnP5Fu/fw/Od5MZo3oiOvKg1z3HWsXO1wrOR2Ub/1iDE2Hg==
=442m
-----END PGP SIGNATURE-----
--- End Message ---
--
Pkg-javascript-devel mailing list
[email protected]
https://alioth-lists.debian.net/cgi-bin/mailman/listinfo/pkg-javascript-devel
