#$@%#$%!

Ngiler SH3LL 360
: / lib / node_modules / npm / node_modules / worker-farm / tests /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : index.js \| Size : 17.65 KB
'use strict' const tape = require('tape') , child_process = require('child_process') , workerFarm = require('../') , childPath = require.resolve('./child') , fs = require('fs') , os = require('os') function uniq (ar) { let a = [], i, j o: for (i = 0; i < ar.length; ++i) { for (j = 0; j < a.length; ++j) if (a[j] == ar[i]) continue o a[a.length] = ar[i] } return a } // a child where module.exports = function ... tape('simple, exports=function test', function (t) { t.plan(4) let child = workerFarm(childPath) child(0, function (err, pid, rnd) { t.ok(pid > process.pid, 'pid makes sense') t.ok(pid < process.pid + 750, 'pid makes sense') t.ok(rnd >= 0 && rnd < 1, 'rnd result makes sense') }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) // a child where we have module.exports.fn = function ... tape('simple, exports.fn test', function (t) { t.plan(4) let child = workerFarm(childPath, [ 'run0' ]) child.run0(function (err, pid, rnd) { t.ok(pid > process.pid, 'pid makes sense') t.ok(pid < process.pid + 750, 'pid makes sense') t.ok(rnd >= 0 && rnd < 1, 'rnd result makes sense') }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) tape('on child', function (t) { t.plan(2) let child = workerFarm({ onChild: function(subprocess) { childPid = subprocess.pid } }, childPath) , childPid = null; child(0, function(err, pid) { t.equal(childPid, pid) }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) // use the returned pids to check that we're using a single child process // when maxConcurrentWorkers = 1 tape('single worker', function (t) { t.plan(2) let child = workerFarm({ maxConcurrentWorkers: 1 }, childPath) , pids = [] , i = 10 while (i--) { child(0, function (err, pid) { pids.push(pid) if (pids.length == 10) { t.equal(1, uniq(pids).length, 'only a single process (by pid)') } else if (pids.length > 10) t.fail('too many callbacks!') }) } workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) // use the returned pids to check that we're using two child processes // when maxConcurrentWorkers = 2 tape('two workers', function (t) { t.plan(2) let child = workerFarm({ maxConcurrentWorkers: 2 }, childPath) , pids = [] , i = 10 while (i--) { child(0, function (err, pid) { pids.push(pid) if (pids.length == 10) { t.equal(2, uniq(pids).length, 'only two child processes (by pid)') } else if (pids.length > 10) t.fail('too many callbacks!') }) } workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) // use the returned pids to check that we're using a child process per // call when maxConcurrentWorkers = 10 tape('many workers', function (t) { t.plan(2) let child = workerFarm({ maxConcurrentWorkers: 10 }, childPath) , pids = [] , i = 10 while (i--) { child(1, function (err, pid) { pids.push(pid) if (pids.length == 10) { t.equal(10, uniq(pids).length, 'pids are all the same (by pid)') } else if (pids.length > 10) t.fail('too many callbacks!') }) } workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) tape('auto start workers', function (t) { let child = workerFarm({ maxConcurrentWorkers: 3, autoStart: true }, childPath, ['uptime']) , pids = [] , count = 5 , i = count , delay = 250 t.plan(count + 1) setTimeout(function() { while (i--) child.uptime(function (err, uptime) { t.ok(uptime > 10, 'child has been up before the request (' + uptime + 'ms)') }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }, delay) }) // use the returned pids to check that we're using a child process per // call when we set maxCallsPerWorker = 1 even when we have maxConcurrentWorkers = 1 tape('single call per worker', function (t) { t.plan(2) let child = workerFarm({ maxConcurrentWorkers: 1 , maxConcurrentCallsPerWorker: Infinity , maxCallsPerWorker: 1 , autoStart: true }, childPath) , pids = [] , count = 25 , i = count while (i--) { child(0, function (err, pid) { pids.push(pid) if (pids.length == count) { t.equal(count, uniq(pids).length, 'one process for each call (by pid)') workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) } else if (pids.length > count) t.fail('too many callbacks!') }) } }) // use the returned pids to check that we're using a child process per // two-calls when we set maxCallsPerWorker = 2 even when we have maxConcurrentWorkers = 1 tape('two calls per worker', function (t) { t.plan(2) let child = workerFarm({ maxConcurrentWorkers: 1 , maxConcurrentCallsPerWorker: Infinity , maxCallsPerWorker: 2 , autoStart: true }, childPath) , pids = [] , count = 20 , i = count while (i--) { child(0, function (err, pid) { pids.push(pid) if (pids.length == count) { t.equal(count / 2, uniq(pids).length, 'one process for each call (by pid)') workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) } else if (pids.length > count) t.fail('too many callbacks!') }) } }) // use timing to confirm that one worker will process calls sequentially tape('many concurrent calls', function (t) { t.plan(2) let child = workerFarm({ maxConcurrentWorkers: 1 , maxConcurrentCallsPerWorker: Infinity , maxCallsPerWorker: Infinity , autoStart: true }, childPath) , defer = 200 , count = 200 , i = count , cbc = 0 setTimeout(function () { let start = Date.now() while (i--) { child(defer, function () { if (++cbc == count) { let time = Date.now() - start // upper-limit not tied to `count` at all t.ok(time > defer && time < (defer * 2.5), 'processed tasks concurrently (' + time + 'ms)') workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) } else if (cbc > count) t.fail('too many callbacks!') }) } }, 250) }) // use timing to confirm that one child processes calls sequentially with // maxConcurrentCallsPerWorker = 1 tape('single concurrent call', function (t) { t.plan(2) let child = workerFarm({ maxConcurrentWorkers: 1 , maxConcurrentCallsPerWorker: 1 , maxCallsPerWorker: Infinity , autoStart: true }, childPath) , defer = 20 , count = 100 , i = count , cbc = 0 setTimeout(function () { let start = Date.now() while (i--) { child(defer, function () { if (++cbc == count) { let time = Date.now() - start // upper-limit tied closely to `count`, 1.3 is generous but accounts for all the timers // coming back at the same time and the IPC overhead t.ok(time > (defer * count) && time < (defer * count * 1.3), 'processed tasks sequentially (' + time + ')') workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) } else if (cbc > count) t.fail('too many callbacks!') }) } }, 250) }) // use timing to confirm that one child processes only 5 calls concurrently tape('multiple concurrent calls', function (t) { t.plan(2) let callsPerWorker = 5 , child = workerFarm({ maxConcurrentWorkers: 1 , maxConcurrentCallsPerWorker: callsPerWorker , maxCallsPerWorker: Infinity , autoStart: true }, childPath) , defer = 100 , count = 100 , i = count , cbc = 0 setTimeout(function () { let start = Date.now() while (i--) { child(defer, function () { if (++cbc == count) { let time = Date.now() - start let min = defer * 1.5 // (defer * (count / callsPerWorker + 2)) - if precise it'd be count/callsPerWorker // but accounting for IPC and other overhead, we need to give it a bit of extra time, // hence the +2 let max = defer * (count / callsPerWorker + 2) t.ok(time > min && time < max, 'processed tasks concurrently (' + time + ' > ' + min + ' && ' + time + ' < ' + max + ')') workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) } else if (cbc > count) t.fail('too many callbacks!') }) } }, 250) }) // call a method that will die with a probability of 0.5 but expect that // we'll get results for each of our calls anyway tape('durability', function (t) { t.plan(3) let child = workerFarm({ maxConcurrentWorkers: 2 }, childPath, [ 'killable' ]) , ids = [] , pids = [] , count = 20 , i = count while (i--) { child.killable(i, function (err, id, pid) { ids.push(id) pids.push(pid) if (ids.length == count) { t.ok(uniq(pids).length > 2, 'processed by many (' + uniq(pids).length + ') workers, but got there in the end!') t.ok(uniq(ids).length == count, 'received a single result for each unique call') workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) } else if (ids.length > count) t.fail('too many callbacks!') }) } }) // a callback provided to .end() can and will be called (uses "simple, exports=function test" to create a child) tape('simple, end callback', function (t) { t.plan(4) let child = workerFarm(childPath) child(0, function (err, pid, rnd) { t.ok(pid > process.pid, 'pid makes sense ' + pid + ' vs ' + process.pid) t.ok(pid < process.pid + 750, 'pid makes sense ' + pid + ' vs ' + process.pid) t.ok(rnd >= 0 && rnd < 1, 'rnd result makes sense') }) workerFarm.end(child, function() { t.pass('an .end() callback was successfully called') }) }) tape('call timeout test', function (t) { t.plan(3 + 3 + 4 + 4 + 4 + 3 + 1) let child = workerFarm({ maxCallTime: 250, maxConcurrentWorkers: 1 }, childPath) // should come back ok child(50, function (err, pid, rnd) { t.ok(pid > process.pid, 'pid makes sense ' + pid + ' vs ' + process.pid) t.ok(pid < process.pid + 750, 'pid makes sense ' + pid + ' vs ' + process.pid) t.ok(rnd > 0 && rnd < 1, 'rnd result makes sense ' + rnd) }) // should come back ok child(50, function (err, pid, rnd) { t.ok(pid > process.pid, 'pid makes sense ' + pid + ' vs ' + process.pid) t.ok(pid < process.pid + 750, 'pid makes sense ' + pid + ' vs ' + process.pid) t.ok(rnd > 0 && rnd < 1, 'rnd result makes sense ' + rnd) }) // should die child(500, function (err, pid, rnd) { t.ok(err, 'got an error') t.equal(err.type, 'TimeoutError', 'correct error type') t.ok(pid === undefined, 'no pid') t.ok(rnd === undefined, 'no rnd') }) // should die child(1000, function (err, pid, rnd) { t.ok(err, 'got an error') t.equal(err.type, 'TimeoutError', 'correct error type') t.ok(pid === undefined, 'no pid') t.ok(rnd === undefined, 'no rnd') }) // should die even though it is only a 100ms task, it'll get caught up // in a dying worker setTimeout(function () { child(100, function (err, pid, rnd) { t.ok(err, 'got an error') t.equal(err.type, 'TimeoutError', 'correct error type') t.ok(pid === undefined, 'no pid') t.ok(rnd === undefined, 'no rnd') }) }, 200) // should be ok, new worker setTimeout(function () { child(50, function (err, pid, rnd) { t.ok(pid > process.pid, 'pid makes sense ' + pid + ' vs ' + process.pid) t.ok(pid < process.pid + 750, 'pid makes sense ' + pid + ' vs ' + process.pid) t.ok(rnd > 0 && rnd < 1, 'rnd result makes sense ' + rnd) }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }, 400) }) tape('test error passing', function (t) { t.plan(10) let child = workerFarm(childPath, [ 'err' ]) child.err('Error', 'this is an Error', function (err) { t.ok(err instanceof Error, 'is an Error object') t.equal('Error', err.type, 'correct type') t.equal('this is an Error', err.message, 'correct message') }) child.err('TypeError', 'this is a TypeError', function (err) { t.ok(err instanceof Error, 'is a TypeError object') t.equal('TypeError', err.type, 'correct type') t.equal('this is a TypeError', err.message, 'correct message') }) child.err('Error', 'this is an Error with custom props', {foo: 'bar', 'baz': 1}, function (err) { t.ok(err instanceof Error, 'is an Error object') t.equal(err.foo, 'bar', 'passes data') t.equal(err.baz, 1, 'passes data') }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) tape('test maxConcurrentCalls', function (t) { t.plan(10) let child = workerFarm({ maxConcurrentCalls: 5 }, childPath) child(50, function (err) { t.notOk(err, 'no error') }) child(50, function (err) { t.notOk(err, 'no error') }) child(50, function (err) { t.notOk(err, 'no error') }) child(50, function (err) { t.notOk(err, 'no error') }) child(50, function (err) { t.notOk(err, 'no error') }) child(50, function (err) { t.ok(err) t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type') }) child(50, function (err) { t.ok(err) t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type') }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) tape('test maxConcurrentCalls + queue', function (t) { t.plan(13) let child = workerFarm({ maxConcurrentCalls: 4, maxConcurrentWorkers: 2, maxConcurrentCallsPerWorker: 1 }, childPath) child(20, function (err) { console.log('ended short1'); t.notOk(err, 'no error, short call 1') }) child(20, function (err) { console.log('ended short2'); t.notOk(err, 'no error, short call 2') }) child(300, function (err) { t.notOk(err, 'no error, long call 1') }) child(300, function (err) { t.notOk(err, 'no error, long call 2') }) child(20, function (err) { t.ok(err, 'short call 3 should error') t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type') }) child(20, function (err) { t.ok(err, 'short call 4 should error') t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type') }) // cross fingers and hope the two short jobs have ended setTimeout(function () { child(20, function (err) { t.notOk(err, 'no error, delayed short call 1') }) child(20, function (err) { t.notOk(err, 'no error, delayed short call 2') }) child(20, function (err) { t.ok(err, 'delayed short call 3 should error') t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type') }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }, 250) }) // this test should not keep the process running! if the test process // doesn't die then the problem is here tape('test timeout kill', function (t) { t.plan(3) let child = workerFarm({ maxCallTime: 250, maxConcurrentWorkers: 1 }, childPath, [ 'block' ]) child.block(function (err) { t.ok(err, 'got an error') t.equal(err.type, 'TimeoutError', 'correct error type') }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) tape('test max retries after process terminate', function (t) { t.plan(7) // temporary file is used to store the number of retries among terminating workers let filepath1 = '.retries1' let child1 = workerFarm({ maxConcurrentWorkers: 1, maxRetries: 5}, childPath, [ 'stubborn' ]) child1.stubborn(filepath1, function (err, result) { t.notOk(err, 'no error') t.equal(result, 12, 'correct result') }) workerFarm.end(child1, function () { fs.unlinkSync(filepath1) t.ok(true, 'workerFarm ended') }) let filepath2 = '.retries2' let child2 = workerFarm({ maxConcurrentWorkers: 1, maxRetries: 3}, childPath, [ 'stubborn' ]) child2.stubborn(filepath2, function (err, result) { t.ok(err, 'got an error') t.equal(err.type, 'ProcessTerminatedError', 'correct error type') t.equal(err.message, 'cancel after 3 retries!', 'correct message and number of retries') }) workerFarm.end(child2, function () { fs.unlinkSync(filepath2) t.ok(true, 'workerFarm ended') }) }) tape('custom arguments can be passed to "fork"', function (t) { t.plan(3) // allocate a real, valid path, in any OS let cwd = fs.realpathSync(os.tmpdir()) , workerOptions = { cwd : cwd , execArgv : ['--expose-gc'] } , child = workerFarm({ maxConcurrentWorkers: 1, maxRetries: 5, workerOptions: workerOptions}, childPath, ['args']) child.args(function (err, result) { t.equal(result.execArgv[0], '--expose-gc', 'flags passed (overridden default)') t.equal(result.cwd, cwd, 'correct cwd folder') }) workerFarm.end(child, function () { t.ok(true, 'workerFarm ended') }) }) tape('ensure --debug/--inspect not propagated to children', function (t) { t.plan(3) let script = __dirname + '/debug.js' , debugArg = process.version.replace(/^v(\d+)\..*$/, '$1') >= 8 ? '--inspect' : '--debug=8881' , child = child_process.spawn(process.execPath, [ debugArg, script ]) , stdout = '' child.stdout.on('data', function (data) { stdout += data.toString() }) child.on('close', function (code) { t.equal(code, 0, 'exited without error (' + code + ')') t.ok(stdout.indexOf('FINISHED') > -1, 'process finished') t.ok(stdout.indexOf('--debug') === -1, 'child does not receive debug flag') }) }) Back

Edit File : index.js | Size : 17.65 KB

'use strict'

const tape          = require('tape')
    , child_process = require('child_process')
    , workerFarm    = require('../')
    , childPath     = require.resolve('./child')
    , fs            = require('fs')
    , os            = require('os')

function uniq (ar) {
  let a = [], i, j
  o: for (i = 0; i < ar.length; ++i) {
    for (j = 0; j < a.length; ++j) if (a[j] == ar[i]) continue o
    a[a.length] = ar[i]
  }
  return a
}

// a child where module.exports = function ...
tape('simple, exports=function test', function (t) {
  t.plan(4)

let child = workerFarm(childPath)
  child(0, function (err, pid, rnd) {
    t.ok(pid > process.pid, 'pid makes sense')
    t.ok(pid < process.pid + 750, 'pid makes sense')
    t.ok(rnd >= 0 && rnd < 1, 'rnd result makes sense')
  })

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

// a child where we have module.exports.fn = function ...
tape('simple, exports.fn test', function (t) {
  t.plan(4)

let child = workerFarm(childPath, [ 'run0' ])
  child.run0(function (err, pid, rnd) {
    t.ok(pid > process.pid, 'pid makes sense')
    t.ok(pid < process.pid + 750, 'pid makes sense')
    t.ok(rnd >= 0 && rnd < 1, 'rnd result makes sense')
  })

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

tape('on child', function (t) {
    t.plan(2)

let child = workerFarm({ onChild: function(subprocess) { childPid = subprocess.pid } }, childPath)
      , childPid = null;

child(0, function(err, pid) {
      t.equal(childPid, pid)
    })

workerFarm.end(child, function () {
      t.ok(true, 'workerFarm ended')
    })
})

// use the returned pids to check that we're using a single child process
// when maxConcurrentWorkers = 1
tape('single worker', function (t) {
  t.plan(2)

let child = workerFarm({ maxConcurrentWorkers: 1 }, childPath)
    , pids  = []
    , i     = 10

while (i--) {
    child(0, function (err, pid) {
      pids.push(pid)
      if (pids.length == 10) {
        t.equal(1, uniq(pids).length, 'only a single process (by pid)')
      } else if (pids.length > 10)
        t.fail('too many callbacks!')
    })
  }

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

// use the returned pids to check that we're using two child processes
// when maxConcurrentWorkers = 2
tape('two workers', function (t) {
  t.plan(2)

let child = workerFarm({ maxConcurrentWorkers: 2 }, childPath)
    , pids  = []
    , i     = 10

while (i--) {
    child(0, function (err, pid) {
      pids.push(pid)
      if (pids.length == 10) {
        t.equal(2, uniq(pids).length, 'only two child processes (by pid)')
      } else if (pids.length > 10)
        t.fail('too many callbacks!')
    })
  }

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

// use the returned pids to check that we're using a child process per
// call when maxConcurrentWorkers = 10
tape('many workers', function (t) {
  t.plan(2)

let child = workerFarm({ maxConcurrentWorkers: 10 }, childPath)
    , pids  = []
    , i     = 10

while (i--) {
    child(1, function (err, pid) {
      pids.push(pid)
      if (pids.length == 10) {
        t.equal(10, uniq(pids).length, 'pids are all the same (by pid)')
      } else if (pids.length > 10)
        t.fail('too many callbacks!')
    })
  }

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

tape('auto start workers', function (t) {
  let child = workerFarm({ maxConcurrentWorkers: 3, autoStart: true }, childPath, ['uptime'])
    , pids  = []
    , count = 5
    , i     = count
    , delay = 250

t.plan(count + 1)

setTimeout(function() {
    while (i--)
      child.uptime(function (err, uptime) {
        t.ok(uptime > 10, 'child has been up before the request (' + uptime + 'ms)')
      })

workerFarm.end(child, function () {
      t.ok(true, 'workerFarm ended')
    })
  }, delay)
})

// use the returned pids to check that we're using a child process per
// call when we set maxCallsPerWorker = 1 even when we have maxConcurrentWorkers = 1
tape('single call per worker', function (t) {
  t.plan(2)

let child = workerFarm({
          maxConcurrentWorkers: 1
        , maxConcurrentCallsPerWorker: Infinity
        , maxCallsPerWorker: 1
        , autoStart: true
      }, childPath)
    , pids  = []
    , count = 25
    , i     = count

while (i--) {
    child(0, function (err, pid) {
      pids.push(pid)
      if (pids.length == count) {
        t.equal(count, uniq(pids).length, 'one process for each call (by pid)')
        workerFarm.end(child, function () {
          t.ok(true, 'workerFarm ended')
        })
      } else if (pids.length > count)
        t.fail('too many callbacks!')
    })
  }
})

// use the returned pids to check that we're using a child process per
// two-calls when we set maxCallsPerWorker = 2 even when we have maxConcurrentWorkers = 1
tape('two calls per worker', function (t) {
  t.plan(2)

let child = workerFarm({
          maxConcurrentWorkers: 1
        , maxConcurrentCallsPerWorker: Infinity
        , maxCallsPerWorker: 2
        , autoStart: true
      }, childPath)
    , pids  = []
    , count = 20
    , i     = count

while (i--) {
    child(0, function (err, pid) {
      pids.push(pid)
      if (pids.length == count) {
        t.equal(count / 2, uniq(pids).length, 'one process for each call (by pid)')
        workerFarm.end(child, function () {
          t.ok(true, 'workerFarm ended')
        })
      } else if (pids.length > count)
        t.fail('too many callbacks!')
    })
  }
})

// use timing to confirm that one worker will process calls sequentially
tape('many concurrent calls', function (t) {
  t.plan(2)

let child = workerFarm({
          maxConcurrentWorkers: 1
        , maxConcurrentCallsPerWorker: Infinity
        , maxCallsPerWorker: Infinity
        , autoStart: true
      }, childPath)
    , defer = 200
    , count = 200
    , i     = count
    , cbc   = 0

setTimeout(function () {
    let start = Date.now()

while (i--) {
      child(defer, function () {
        if (++cbc == count) {
          let time = Date.now() - start
          // upper-limit not tied to `count` at all
          t.ok(time > defer && time < (defer * 2.5), 'processed tasks concurrently (' + time + 'ms)')
          workerFarm.end(child, function () {
            t.ok(true, 'workerFarm ended')
          })
        } else if (cbc > count)
          t.fail('too many callbacks!')
      })
    }
  }, 250)
})

// use timing to confirm that one child processes calls sequentially with
// maxConcurrentCallsPerWorker = 1
tape('single concurrent call', function (t) {
  t.plan(2)

let child = workerFarm({
          maxConcurrentWorkers: 1
        , maxConcurrentCallsPerWorker: 1
        , maxCallsPerWorker: Infinity
        , autoStart: true
      }, childPath)
    , defer = 20
    , count = 100
    , i     = count
    , cbc   = 0

setTimeout(function () {
    let start = Date.now()

while (i--) {
      child(defer, function () {
        if (++cbc == count) {
          let time = Date.now() - start
          // upper-limit tied closely to `count`, 1.3 is generous but accounts for all the timers
          // coming back at the same time and the IPC overhead
          t.ok(time > (defer * count) && time < (defer * count * 1.3), 'processed tasks sequentially (' + time + ')')
          workerFarm.end(child, function () {
            t.ok(true, 'workerFarm ended')
          })
        } else if (cbc > count)
          t.fail('too many callbacks!')
      })
    }
  }, 250)
})

// use timing to confirm that one child processes *only* 5 calls concurrently
tape('multiple concurrent calls', function (t) {
  t.plan(2)

let callsPerWorker = 5
    , child = workerFarm({
          maxConcurrentWorkers: 1
        , maxConcurrentCallsPerWorker: callsPerWorker
        , maxCallsPerWorker: Infinity
        , autoStart: true
      }, childPath)
    , defer = 100
    , count = 100
    , i     = count
    , cbc   = 0

setTimeout(function () {
    let start = Date.now()

while (i--) {
      child(defer, function () {
        if (++cbc == count) {
          let time = Date.now() - start
          let min = defer * 1.5
          // (defer * (count / callsPerWorker + 2)) - if precise it'd be count/callsPerWorker
          // but accounting for IPC and other overhead, we need to give it a bit of extra time,
          // hence the +2
          let max = defer * (count / callsPerWorker + 2)
          t.ok(time > min && time < max, 'processed tasks concurrently (' + time + ' > ' + min + ' && ' + time + ' < ' + max + ')')
          workerFarm.end(child, function () {
            t.ok(true, 'workerFarm ended')
          })
        } else if (cbc > count)
          t.fail('too many callbacks!')
      })
    }
  }, 250)
})

// call a method that will die with a probability of 0.5 but expect that
// we'll get results for each of our calls anyway
tape('durability', function (t) {
  t.plan(3)

let child = workerFarm({ maxConcurrentWorkers: 2 }, childPath, [ 'killable' ])
    , ids   = []
    , pids  = []
    , count = 20
    , i     = count

while (i--) {
    child.killable(i, function (err, id, pid) {
      ids.push(id)
      pids.push(pid)
      if (ids.length == count) {
        t.ok(uniq(pids).length > 2, 'processed by many (' + uniq(pids).length + ') workers, but got there in the end!')
        t.ok(uniq(ids).length == count, 'received a single result for each unique call')
        workerFarm.end(child, function () {
          t.ok(true, 'workerFarm ended')
        })
      } else if (ids.length > count)
        t.fail('too many callbacks!')
    })
  }
})

// a callback provided to .end() can and will be called (uses "simple, exports=function test" to create a child)
tape('simple, end callback', function (t) {
  t.plan(4)

let child = workerFarm(childPath)
  child(0, function (err, pid, rnd) {
    t.ok(pid > process.pid, 'pid makes sense ' + pid + ' vs ' + process.pid)
    t.ok(pid < process.pid + 750, 'pid makes sense ' + pid + ' vs ' + process.pid)
    t.ok(rnd >= 0 && rnd < 1, 'rnd result makes sense')
  })

workerFarm.end(child, function() {
    t.pass('an .end() callback was successfully called')
  })
})

tape('call timeout test', function (t) {
  t.plan(3 + 3 + 4 + 4 + 4 + 3 + 1)

let child = workerFarm({ maxCallTime: 250, maxConcurrentWorkers: 1 }, childPath)

// should come back ok
  child(50, function (err, pid, rnd) {
    t.ok(pid > process.pid, 'pid makes sense ' + pid + ' vs ' + process.pid)
    t.ok(pid < process.pid + 750, 'pid makes sense ' + pid + ' vs ' + process.pid)
    t.ok(rnd > 0 && rnd < 1, 'rnd result makes sense ' + rnd)
  })

// should die
  child(500, function (err, pid, rnd) {
    t.ok(err, 'got an error')
    t.equal(err.type, 'TimeoutError', 'correct error type')
    t.ok(pid === undefined, 'no pid')
    t.ok(rnd === undefined, 'no rnd')
  })

// should die
  child(1000, function (err, pid, rnd) {
    t.ok(err, 'got an error')
    t.equal(err.type, 'TimeoutError', 'correct error type')
    t.ok(pid === undefined, 'no pid')
    t.ok(rnd === undefined, 'no rnd')
  })

// should die even though it is only a 100ms task, it'll get caught up
  // in a dying worker
  setTimeout(function () {
    child(100, function (err, pid, rnd) {
      t.ok(err, 'got an error')
      t.equal(err.type, 'TimeoutError', 'correct error type')
      t.ok(pid === undefined, 'no pid')
      t.ok(rnd === undefined, 'no rnd')
    })
  }, 200)

// should be ok, new worker
  setTimeout(function () {
    child(50, function (err, pid, rnd) {
      t.ok(pid > process.pid, 'pid makes sense ' + pid + ' vs ' + process.pid)
      t.ok(pid < process.pid + 750, 'pid makes sense ' + pid + ' vs ' + process.pid)
      t.ok(rnd > 0 && rnd < 1, 'rnd result makes sense ' + rnd)
    })
    workerFarm.end(child, function () {
      t.ok(true, 'workerFarm ended')
    })
  }, 400)
})

tape('test error passing', function (t) {
  t.plan(10)

let child = workerFarm(childPath, [ 'err' ])
  child.err('Error', 'this is an Error', function (err) {
    t.ok(err instanceof Error, 'is an Error object')
    t.equal('Error', err.type, 'correct type')
    t.equal('this is an Error', err.message, 'correct message')
  })
  child.err('TypeError', 'this is a TypeError', function (err) {
    t.ok(err instanceof Error, 'is a TypeError object')
    t.equal('TypeError', err.type, 'correct type')
    t.equal('this is a TypeError', err.message, 'correct message')
  })
  child.err('Error', 'this is an Error with custom props', {foo: 'bar', 'baz': 1}, function (err) {
    t.ok(err instanceof Error, 'is an Error object')
    t.equal(err.foo, 'bar', 'passes data')
    t.equal(err.baz, 1, 'passes data')
  })

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

tape('test maxConcurrentCalls', function (t) {
  t.plan(10)

let child = workerFarm({ maxConcurrentCalls: 5 }, childPath)

child(50, function (err) { t.notOk(err, 'no error') })
  child(50, function (err) { t.notOk(err, 'no error') })
  child(50, function (err) { t.notOk(err, 'no error') })
  child(50, function (err) { t.notOk(err, 'no error') })
  child(50, function (err) { t.notOk(err, 'no error') })
  child(50, function (err) {
    t.ok(err)
    t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type')
  })
  child(50, function (err) {
    t.ok(err)
    t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type')
  })

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

tape('test maxConcurrentCalls + queue', function (t) {
  t.plan(13)

let child = workerFarm({ maxConcurrentCalls: 4, maxConcurrentWorkers: 2, maxConcurrentCallsPerWorker: 1 }, childPath)

child(20, function (err) { console.log('ended short1'); t.notOk(err, 'no error, short call 1') })
  child(20, function (err) { console.log('ended short2'); t.notOk(err, 'no error, short call 2') })
  child(300, function (err) { t.notOk(err, 'no error, long call 1') })
  child(300, function (err) { t.notOk(err, 'no error, long call 2') })
  child(20, function (err) {
    t.ok(err, 'short call 3 should error')
    t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type')
  })
  child(20, function (err) {
    t.ok(err, 'short call 4 should error')
    t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type')
  })

// cross fingers and hope the two short jobs have ended
  setTimeout(function () {
    child(20, function (err) { t.notOk(err, 'no error, delayed short call 1') })
    child(20, function (err) { t.notOk(err, 'no error, delayed short call 2') })
    child(20, function (err) {
      t.ok(err, 'delayed short call 3 should error')
      t.equal(err.type, 'MaxConcurrentCallsError', 'correct error type')
    })

workerFarm.end(child, function () {
      t.ok(true, 'workerFarm ended')
    })
  }, 250)
})

// this test should not keep the process running! if the test process
// doesn't die then the problem is here
tape('test timeout kill', function (t) {
  t.plan(3)

let child = workerFarm({ maxCallTime: 250, maxConcurrentWorkers: 1 }, childPath, [ 'block' ])
  child.block(function (err) {
    t.ok(err, 'got an error')
    t.equal(err.type, 'TimeoutError', 'correct error type')
  })

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

tape('test max retries after process terminate', function (t) {
  t.plan(7)

// temporary file is used to store the number of retries among terminating workers
  let filepath1 = '.retries1'
  let child1 = workerFarm({ maxConcurrentWorkers: 1, maxRetries: 5}, childPath, [ 'stubborn' ])
  child1.stubborn(filepath1, function (err, result) {
    t.notOk(err, 'no error')
    t.equal(result, 12, 'correct result')
  })

workerFarm.end(child1, function () {
    fs.unlinkSync(filepath1)
    t.ok(true, 'workerFarm ended')
  })

let filepath2 = '.retries2'
  let child2 = workerFarm({ maxConcurrentWorkers: 1, maxRetries: 3}, childPath, [ 'stubborn' ])
  child2.stubborn(filepath2, function (err, result) {
    t.ok(err, 'got an error')
    t.equal(err.type, 'ProcessTerminatedError', 'correct error type')
    t.equal(err.message, 'cancel after 3 retries!', 'correct message and number of retries')
  })

workerFarm.end(child2, function () {
    fs.unlinkSync(filepath2)
    t.ok(true, 'workerFarm ended')
  })
})

tape('custom arguments can be passed to "fork"', function (t) {
  t.plan(3)

// allocate a real, valid path, in any OS
  let cwd = fs.realpathSync(os.tmpdir())
    , workerOptions = {
        cwd      : cwd
      , execArgv : ['--expose-gc']
    }
    , child = workerFarm({ maxConcurrentWorkers: 1, maxRetries: 5, workerOptions: workerOptions}, childPath, ['args'])

child.args(function (err, result) {
    t.equal(result.execArgv[0], '--expose-gc', 'flags passed (overridden default)')
    t.equal(result.cwd, cwd, 'correct cwd folder')
  })

workerFarm.end(child, function () {
    t.ok(true, 'workerFarm ended')
  })
})

tape('ensure --debug/--inspect not propagated to children', function (t) {
  t.plan(3)

let script   = __dirname + '/debug.js'
    , debugArg = process.version.replace(/^v(\d+)\..*$/, '$1') >= 8 ? '--inspect' : '--debug=8881'
    , child    = child_process.spawn(process.execPath, [ debugArg, script ])
    , stdout   = ''

child.stdout.on('data', function (data) {
    stdout += data.toString()
  })

child.on('close', function (code) {
    t.equal(code, 0, 'exited without error (' + code + ')')
    t.ok(stdout.indexOf('FINISHED') > -1, 'process finished')
    t.ok(stdout.indexOf('--debug') === -1, 'child does not receive debug flag')
  })
})

Back