pax_global_header00006660000000000000000000000064137676345170014535gustar00rootroot0000000000000052 comment=9b929c0ac40fe6b1ea0d2c4560dddf0d4be4851e fastq-1.10.0/000077500000000000000000000000001376763451700127325ustar00rootroot00000000000000fastq-1.10.0/.github/000077500000000000000000000000001376763451700142725ustar00rootroot00000000000000fastq-1.10.0/.github/workflows/000077500000000000000000000000001376763451700163275ustar00rootroot00000000000000fastq-1.10.0/.github/workflows/ci.yml000066400000000000000000000016151376763451700174500ustar00rootroot00000000000000name: ci on: [push, pull_request] jobs: legacy: runs-on: ubuntu-latest strategy: matrix: node-version: ['0.10', '0.12', 4.x, 6.x, 8.x] steps: - uses: actions/checkout@v2 - name: Use Node.js uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} - name: Install run: | npm install --production && npm install tape - name: Run tests run: | npm run legacy test: runs-on: ubuntu-latest strategy: matrix: node-version: [10.x, 12.x, 13.x, 14.x, 15.x] steps: - uses: actions/checkout@v2 - name: Use Node.js uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} - name: Install run: | npm install - name: Run tests run: | npm run test fastq-1.10.0/.gitignore000066400000000000000000000010661376763451700147250ustar00rootroot00000000000000# Logs logs *.log # Runtime data pids *.pid *.seed # Directory for instrumented libs generated by jscoverage/JSCover lib-cov # Coverage directory used by tools like nyc coverage .nyc_output # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) .grunt # node-waf configuration .lock-wscript # Compiled binary addons (http://nodejs.org/api/addons.html) build/Release # Dependency directory # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git node_modules # package-lock package-lock.jsonfastq-1.10.0/LICENSE000066400000000000000000000013751376763451700137450ustar00rootroot00000000000000Copyright (c) 2015-2020, Matteo Collina Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. fastq-1.10.0/README.md000066400000000000000000000130151376763451700142110ustar00rootroot00000000000000# fastq ![ci][ci-url] [![npm version][npm-badge]][npm-url] [![Dependency Status][david-badge]][david-url] Fast, in memory work queue. Benchmarks (1 million tasks): * setImmediate: 812ms * fastq: 854ms * async.queue: 1298ms * neoAsync.queue: 1249ms Obtained on node 12.16.1, on a dedicated server. If you need zero-overhead series function call, check out [fastseries](http://npm.im/fastseries). For zero-overhead parallel function call, check out [fastparallel](http://npm.im/fastparallel). [![js-standard-style](https://raw.githubusercontent.com/feross/standard/master/badge.png)](https://github.com/feross/standard) * Installation * Usage * API * Licence & copyright ## Install `npm i fastq --save` ## Usage ```js 'use strict' var queue = require('fastq')(worker, 1) queue.push(42, function (err, result) { if (err) { throw err } console.log('the result is', result) }) function worker (arg, cb) { cb(null, 42 * 2) } ``` ### Setting this ```js 'use strict' var that = { hello: 'world' } var queue = require('fastq')(that, worker, 1) queue.push(42, function (err, result) { if (err) { throw err } console.log(this) console.log('the result is', result) }) function worker (arg, cb) { console.log(this) cb(null, 42 * 2) } ``` ## API * fastqueue() * queue#push() * queue#unshift() * queue#pause() * queue#resume() * queue#idle() * queue#length() * queue#getQueue() * queue#kill() * queue#killAndDrain() * queue#error() * queue#concurrency * queue#drain * queue#empty * queue#saturated ------------------------------------------------------- ### fastqueue([that], worker, concurrency) Creates a new queue. Arguments: * `that`, optional context of the `worker` function. * `worker`, worker function, it would be called with `that` as `this`, if that is specified. * `concurrency`, number of concurrent tasks that could be executed in parallel. ------------------------------------------------------- ### queue.push(task, done) Add a task at the end of the queue. `done(err, result)` will be called when the task was processed. ------------------------------------------------------- ### queue.unshift(task, done) Add a task at the beginning of the queue. `done(err, result)` will be called when the task was processed. ------------------------------------------------------- ### queue.pause() Pause the processing of tasks. Currently worked tasks are not stopped. ------------------------------------------------------- ### queue.resume() Resume the processing of tasks. ------------------------------------------------------- ### queue.idle() Returns `false` if there are tasks being processed or waiting to be processed. `true` otherwise. ------------------------------------------------------- ### queue.length() Returns the number of tasks waiting to be processed (in the queue). ------------------------------------------------------- ### queue.getQueue() Returns all the tasks be processed (in the queue). Returns empty array when there are no tasks ------------------------------------------------------- ### queue.kill() Removes all tasks waiting to be processed, and reset `drain` to an empty function. ------------------------------------------------------- ### queue.killAndDrain() Same than `kill` but the `drain` function will be called before reset to empty. ------------------------------------------------------- ### queue.error(handler) Set a global error handler. `handler(err, task)` will be called when any of the tasks return an error. ------------------------------------------------------- ### queue.concurrency Property that returns the number of concurrent tasks that could be executed in parallel. It can be altered at runtime. ------------------------------------------------------- ### queue.drain Function that will be called when the last item from the queue has been processed by a worker. It can be altered at runtime. ------------------------------------------------------- ### queue.empty Function that will be called when the last item from the queue has been assigned to a worker. It can be altered at runtime. ------------------------------------------------------- ### queue.saturated Function that will be called when the queue hits the concurrency limit. It can be altered at runtime. ## License ISC [ci-url]: https://github.com/mcollina/fastq/workflows/ci/badge.svg [npm-badge]: https://badge.fury.io/js/fastq.svg [npm-url]: https://badge.fury.io/js/fastq [david-badge]: https://david-dm.org/mcollina/fastq.svg [david-url]: https://david-dm.org/mcollina/fastq fastq-1.10.0/bench.js000066400000000000000000000016431376763451700143530ustar00rootroot00000000000000'use strict' var max = 1000000 var fastqueue = require('./')(worker, 1) var async = require('async') var neo = require('neo-async') var asyncqueue = async.queue(worker, 1) var neoqueue = neo.queue(worker, 1) function bench (func, done) { var key = max + '*' + func.name var count = -1 console.time(key) end() function end () { if (++count < max) { func(end) } else { console.timeEnd(key) if (done) { done() } } } } function benchFastQ (done) { fastqueue.push(42, done) } function benchAsyncQueue (done) { asyncqueue.push(42, done) } function benchNeoQueue (done) { neoqueue.push(42, done) } function worker (arg, cb) { setImmediate(cb) } function benchSetImmediate (cb) { worker(42, cb) } function runBench (done) { async.eachSeries([ benchSetImmediate, benchFastQ, benchNeoQueue, benchAsyncQueue ], bench, done) } runBench(runBench) fastq-1.10.0/example.js000066400000000000000000000003211376763451700147170ustar00rootroot00000000000000'use strict' var queue = require('./')(worker, 1) queue.push(42, function (err, result) { if (err) { throw err } console.log('the result is', result) }) function worker (arg, cb) { cb(null, 42 * 2) } fastq-1.10.0/index.d.ts000066400000000000000000000015621376763451700146370ustar00rootroot00000000000000declare function fastq(context: C, worker: fastq.worker, concurrency: number): fastq.queue declare function fastq(worker: fastq.worker, concurrency: number): fastq.queue declare namespace fastq { type worker = (this: C, task: T, cb: fastq.done) => void type done = (err: Error | null, result?: R) => void type errorHandler = (err: Error, task: T) => void interface queue { push(task: T, done: done): void unshift(task: T, done: done): void pause(): any resume(): any idle(): boolean length(): number getQueue(): T[] kill(): any killAndDrain(): any error(handler: errorHandler): void concurrency: number drain(): any empty: () => void saturated: () => void } } export = fastq fastq-1.10.0/package.json000066400000000000000000000024031376763451700152170ustar00rootroot00000000000000{ "name": "fastq", "version": "1.10.0", "description": "Fast, in memory work queue", "main": "queue.js", "scripts": { "lint": "standard --verbose | snazzy", "unit": "nyc --lines 100 --branches 100 --functions 100 --check-coverage --reporter=text tape test/test.js", "coverage": "nyc --reporter=html --reporter=cobertura --reporter=text tape test/test.js", "test:report": "npm run lint && npm run unit:report", "test": "npm run lint && npm run unit && npm run typescript", "typescript": "tsc --project ./test/tsconfig.json", "legacy": "tape test/test.js" }, "pre-commit": [ "test" ], "repository": { "type": "git", "url": "git+https://github.com/mcollina/fastq.git" }, "keywords": [ "fast", "queue", "async", "worker" ], "author": "Matteo Collina ", "license": "ISC", "bugs": { "url": "https://github.com/mcollina/fastq/issues" }, "homepage": "https://github.com/mcollina/fastq#readme", "devDependencies": { "async": "^3.1.0", "neo-async": "^2.6.1", "nyc": "^15.0.0", "pre-commit": "^1.2.2", "snazzy": "^9.0.0", "standard": "^15.0.0", "tape": "^5.0.0", "typescript": "^4.0.2" }, "dependencies": { "reusify": "^1.0.4" } } fastq-1.10.0/queue.js000066400000000000000000000075151376763451700144240ustar00rootroot00000000000000'use strict' var reusify = require('reusify') function fastqueue (context, worker, concurrency) { if (typeof context === 'function') { concurrency = worker worker = context context = null } if (concurrency < 1) { throw new Error('fastqueue concurrency must be greater than 1') } var cache = reusify(Task) var queueHead = null var queueTail = null var _running = 0 var errorHandler = null var self = { push: push, drain: noop, saturated: noop, pause: pause, paused: false, concurrency: concurrency, running: running, resume: resume, idle: idle, length: length, getQueue: getQueue, unshift: unshift, empty: noop, kill: kill, killAndDrain: killAndDrain, error: error } return self function running () { return _running } function pause () { self.paused = true } function length () { var current = queueHead var counter = 0 while (current) { current = current.next counter++ } return counter } function getQueue () { var current = queueHead var tasks = [] while (current) { tasks.push(current.value) current = current.next } return tasks } function resume () { if (!self.paused) return self.paused = false for (var i = 0; i < self.concurrency; i++) { _running++ release() } } function idle () { return _running === 0 && self.length() === 0 } function push (value, done) { var current = cache.get() current.context = context current.release = release current.value = value current.callback = done || noop current.errorHandler = errorHandler if (_running === self.concurrency || self.paused) { if (queueTail) { queueTail.next = current queueTail = current } else { queueHead = current queueTail = current self.saturated() } } else { _running++ worker.call(context, current.value, current.worked) } } function unshift (value, done) { var current = cache.get() current.context = context current.release = release current.value = value current.callback = done || noop if (_running === self.concurrency || self.paused) { if (queueHead) { current.next = queueHead queueHead = current } else { queueHead = current queueTail = current self.saturated() } } else { _running++ worker.call(context, current.value, current.worked) } } function release (holder) { if (holder) { cache.release(holder) } var next = queueHead if (next) { if (!self.paused) { if (queueTail === queueHead) { queueTail = null } queueHead = next.next next.next = null worker.call(context, next.value, next.worked) if (queueTail === null) { self.empty() } } else { _running-- } } else if (--_running === 0) { self.drain() } } function kill () { queueHead = null queueTail = null self.drain = noop } function killAndDrain () { queueHead = null queueTail = null self.drain() self.drain = noop } function error (handler) { errorHandler = handler } } function noop () {} function Task () { this.value = null this.callback = noop this.next = null this.release = noop this.context = null this.errorHandler = null var self = this this.worked = function worked (err, result) { var callback = self.callback var errorHandler = self.errorHandler var val = self.value self.value = null self.callback = noop if (self.errorHandler) { errorHandler(err, val) } callback.call(self.context, err, result) self.release(self) } } module.exports = fastqueue fastq-1.10.0/test/000077500000000000000000000000001376763451700137115ustar00rootroot00000000000000fastq-1.10.0/test/example.ts000066400000000000000000000021511376763451700157130ustar00rootroot00000000000000import * as fastq from '../' // Basic example const queue = fastq(worker, 1) queue.push('world', (err, result) => { if (err) throw err console.log('the result is', result) }) queue.concurrency queue.drain() queue.empty = () => undefined console.log('the queue tasks are', queue.getQueue()) queue.idle() queue.kill() queue.killAndDrain() queue.length queue.pause() queue.resume() queue.saturated = () => undefined queue.unshift('world', (err, result) => { if (err) throw err console.log('the result is', result) }) function worker(task: any, cb: fastq.done) { cb(null, 'hello ' + task) } // Generics example interface GenericsContext { base: number; } const genericsQueue = fastq({ base: 6 }, genericsWorker, 1) genericsQueue.push(7, (err, done) => { if (err) throw err console.log('the result is', done) }) genericsQueue.unshift(7, (err, done) => { if (err) throw err console.log('the result is', done) }) function genericsWorker(this: GenericsContext, task: number, cb: fastq.done) { cb(null, 'the meaning of life is ' + (this.base * task)) } fastq-1.10.0/test/test.js000066400000000000000000000265131376763451700152350ustar00rootroot00000000000000'use strict' var test = require('tape') var buildQueue = require('../') test('concurrency', function (t) { t.plan(2) t.throws(buildQueue.bind(null, worker, 0)) t.doesNotThrow(buildQueue.bind(null, worker, 1)) function worker (arg, cb) { cb(null, true) } }) test('worker execution', function (t) { t.plan(3) var queue = buildQueue(worker, 1) queue.push(42, function (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') }) function worker (arg, cb) { t.equal(arg, 42) cb(null, true) } }) test('limit', function (t) { t.plan(4) var expected = [10, 0] var queue = buildQueue(worker, 1) queue.push(10, result) queue.push(0, result) function result (err, arg) { t.error(err, 'no error') t.equal(arg, expected.shift(), 'the result matches') } function worker (arg, cb) { setTimeout(cb, arg, null, arg) } }) test('multiple executions', function (t) { t.plan(15) var queue = buildQueue(worker, 1) var toExec = [1, 2, 3, 4, 5] var count = 0 toExec.forEach(function (task) { queue.push(task, done) }) function done (err, result) { t.error(err, 'no error') t.equal(result, toExec[count - 1], 'the result matches') } function worker (arg, cb) { t.equal(arg, toExec[count], 'arg matches') count++ setImmediate(cb, null, arg) } }) test('multiple executions, one after another', function (t) { t.plan(15) var queue = buildQueue(worker, 1) var toExec = [1, 2, 3, 4, 5] var count = 0 queue.push(toExec[0], done) function done (err, result) { t.error(err, 'no error') t.equal(result, toExec[count - 1], 'the result matches') if (count < toExec.length) { queue.push(toExec[count], done) } } function worker (arg, cb) { t.equal(arg, toExec[count], 'arg matches') count++ setImmediate(cb, null, arg) } }) test('set this', function (t) { t.plan(3) var that = {} var queue = buildQueue(that, worker, 1) queue.push(42, function (err, result) { t.error(err, 'no error') t.equal(this, that, 'this matches') }) function worker (arg, cb) { t.equal(this, that, 'this matches') cb(null, true) } }) test('drain', function (t) { t.plan(4) var queue = buildQueue(worker, 1) var worked = false queue.push(42, function (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') }) queue.drain = function () { t.equal(true, worked, 'drained') } function worker (arg, cb) { t.equal(arg, 42) worked = true setImmediate(cb, null, true) } }) test('pause && resume', function (t) { t.plan(7) var queue = buildQueue(worker, 1) var worked = false t.notOk(queue.paused, 'it should not be paused') queue.pause() queue.push(42, function (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') }) t.notOk(worked, 'it should be paused') t.ok(queue.paused, 'it should be paused') queue.resume() queue.resume() // second resume is a no-op t.notOk(queue.paused, 'it should not be paused') function worker (arg, cb) { t.equal(arg, 42) worked = true cb(null, true) } }) test('pause in flight && resume', function (t) { t.plan(9) var queue = buildQueue(worker, 1) var expected = [42, 24] t.notOk(queue.paused, 'it should not be paused') queue.push(42, function (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') t.ok(queue.paused, 'it should be paused') process.nextTick(function () { queue.resume() }) }) queue.push(24, function (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') t.notOk(queue.paused, 'it should not be paused') }) queue.pause() function worker (arg, cb) { t.equal(arg, expected.shift()) process.nextTick(function () { cb(null, true) }) } }) test('altering concurrency', function (t) { t.plan(7) var queue = buildQueue(worker, 1) var count = 0 queue.pause() queue.push(24, workDone) queue.push(24, workDone) queue.concurrency = 2 queue.resume() t.equal(queue.running(), 2, '2 jobs running') function workDone (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') } function worker (arg, cb) { t.equal(0, count, 'works in parallel') setImmediate(function () { count++ cb(null, true) }) } }) test('idle()', function (t) { t.plan(12) var queue = buildQueue(worker, 1) t.ok(queue.idle(), 'queue is idle') queue.push(42, function (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') t.notOk(queue.idle(), 'queue is not idle') }) queue.push(42, function (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') // it will go idle after executing this function setImmediate(function () { t.ok(queue.idle(), 'queue is now idle') }) }) t.notOk(queue.idle(), 'queue is not idle') function worker (arg, cb) { t.notOk(queue.idle(), 'queue is not idle') t.equal(arg, 42) setImmediate(cb, null, true) } }) test('saturated', function (t) { t.plan(9) var queue = buildQueue(worker, 1) var preworked = 0 var worked = 0 queue.saturated = function () { t.pass('saturated') t.equal(preworked, 1, 'started 1 task') t.equal(worked, 0, 'worked zero task') } queue.push(42, done) queue.push(42, done) function done (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') } function worker (arg, cb) { t.equal(arg, 42) preworked++ setImmediate(function () { worked++ cb(null, true) }) } }) test('length', function (t) { t.plan(7) var queue = buildQueue(worker, 1) t.equal(queue.length(), 0, 'nothing waiting') queue.push(42, done) t.equal(queue.length(), 0, 'nothing waiting') queue.push(42, done) t.equal(queue.length(), 1, 'one task waiting') queue.push(42, done) t.equal(queue.length(), 2, 'two tasks waiting') function done (err, result) { t.error(err, 'no error') } function worker (arg, cb) { setImmediate(function () { cb(null, true) }) } }) test('getQueue', function (t) { t.plan(10) var queue = buildQueue(worker, 1) t.equal(queue.getQueue().length, 0, 'nothing waiting') queue.push(42, done) t.equal(queue.getQueue().length, 0, 'nothing waiting') queue.push(42, done) t.equal(queue.getQueue().length, 1, 'one task waiting') t.equal(queue.getQueue()[0], 42, 'should be equal') queue.push(43, done) t.equal(queue.getQueue().length, 2, 'two tasks waiting') t.equal(queue.getQueue()[0], 42, 'should be equal') t.equal(queue.getQueue()[1], 43, 'should be equal') function done (err, result) { t.error(err, 'no error') } function worker (arg, cb) { setImmediate(function () { cb(null, true) }) } }) test('unshift', function (t) { t.plan(8) var queue = buildQueue(worker, 1) var expected = [1, 2, 3, 4] queue.push(1, done) queue.push(4, done) queue.unshift(3, done) queue.unshift(2, done) function done (err, result) { t.error(err, 'no error') } function worker (arg, cb) { t.equal(expected.shift(), arg, 'tasks come in order') setImmediate(function () { cb(null, true) }) } }) test('unshift && empty', function (t) { t.plan(2) var queue = buildQueue(worker, 1) var completed = false queue.pause() queue.empty = function () { t.notOk(completed, 'the task has not completed yet') } queue.unshift(1, done) queue.resume() function done (err, result) { completed = true t.error(err, 'no error') } function worker (arg, cb) { setImmediate(function () { cb(null, true) }) } }) test('push && empty', function (t) { t.plan(2) var queue = buildQueue(worker, 1) var completed = false queue.pause() queue.empty = function () { t.notOk(completed, 'the task has not completed yet') } queue.push(1, done) queue.resume() function done (err, result) { completed = true t.error(err, 'no error') } function worker (arg, cb) { setImmediate(function () { cb(null, true) }) } }) test('kill', function (t) { t.plan(5) var queue = buildQueue(worker, 1) var expected = [1] var predrain = queue.drain queue.drain = function drain () { t.fail('drain should never be called') } queue.push(1, done) queue.push(4, done) queue.unshift(3, done) queue.unshift(2, done) queue.kill() function done (err, result) { t.error(err, 'no error') setImmediate(function () { t.equal(queue.length(), 0, 'no queued tasks') t.equal(queue.running(), 0, 'no running tasks') t.equal(queue.drain, predrain, 'drain is back to default') }) } function worker (arg, cb) { t.equal(expected.shift(), arg, 'tasks come in order') setImmediate(function () { cb(null, true) }) } }) test('killAndDrain', function (t) { t.plan(6) var queue = buildQueue(worker, 1) var expected = [1] var predrain = queue.drain queue.drain = function drain () { t.pass('drain has been called') } queue.push(1, done) queue.push(4, done) queue.unshift(3, done) queue.unshift(2, done) queue.killAndDrain() function done (err, result) { t.error(err, 'no error') setImmediate(function () { t.equal(queue.length(), 0, 'no queued tasks') t.equal(queue.running(), 0, 'no running tasks') t.equal(queue.drain, predrain, 'drain is back to default') }) } function worker (arg, cb) { t.equal(expected.shift(), arg, 'tasks come in order') setImmediate(function () { cb(null, true) }) } }) test('pause && idle', function (t) { t.plan(11) var queue = buildQueue(worker, 1) var worked = false t.notOk(queue.paused, 'it should not be paused') t.ok(queue.idle(), 'should be idle') queue.pause() queue.push(42, function (err, result) { t.error(err, 'no error') t.equal(result, true, 'result matches') }) t.notOk(worked, 'it should be paused') t.ok(queue.paused, 'it should be paused') t.notOk(queue.idle(), 'should not be idle') queue.resume() t.notOk(queue.paused, 'it should not be paused') t.notOk(queue.idle(), 'it should not be idle') function worker (arg, cb) { t.equal(arg, 42) worked = true process.nextTick(cb.bind(null, null, true)) process.nextTick(function () { t.ok(queue.idle(), 'is should be idle') }) } }) test('push without cb', function (t) { t.plan(1) var queue = buildQueue(worker, 1) queue.push(42) function worker (arg, cb) { t.equal(arg, 42) cb() } }) test('unshift without cb', function (t) { t.plan(1) var queue = buildQueue(worker, 1) queue.unshift(42) function worker (arg, cb) { t.equal(arg, 42) cb() } }) test('push with worker throwing error', function (t) { t.plan(5) var q = buildQueue(function (task, cb) { cb(new Error('test error'), null) }, 1) q.error(function (err, task) { t.ok(err instanceof Error, 'global error handler should catch the error') t.match(err.message, /test error/, 'error message should be "test error"') t.equal(task, 42, 'The task executed should be passed') }) q.push(42, function (err) { t.ok(err instanceof Error, 'push callback should catch the error') t.match(err.message, /test error/, 'error message should be "test error"') }) }) fastq-1.10.0/test/tsconfig.json000066400000000000000000000002321376763451700164150ustar00rootroot00000000000000{ "compilerOptions": { "target": "es6", "module": "commonjs", "noEmit": true, "strict": true }, "files": [ "./example.ts" ] }