timeout (120, new Promise (return_ => {

const ps = require ('child_process').spawn (bin, args)

let output = ''

let stderr = ''

let hasWarnings = false

ps.stdout.on ('data', data => { output += data.toString () })

ps.stderr.on ('data', data => { output += data.toString (); stderr += data.toString (); hasWarnings = true })

ps.on ('exit', code => {

output = ansi.strip (output.trim ())

stderr = ansi.strip (stderr)

const regex = /\[[a-z]+?\]/gmi

let match = undefined

const warnings = []

match = regex.exec (output)

if (match) {

warnings.push (match[0])

do {

if (match = regex.exec (output)) {

warnings.push (match[0])

}

} while (match);

}

return_ ({

failed: code !== 0,

output,

hasOutput: output.length > 0,

hasWarnings: hasWarnings || warnings.length > 0,

warnings: warnings,

})

})

})).catch (e => ({

failed: true,

output: e.message

const result = []

for (const item of input) { result.push (await fn (item)) }

return result

const args = [exchange, ...symbol === 'all' ? [] : symbol]

, allTests = [

{ language: 'JavaScript', key: '--js', exec: ['node', 'js/test/test.js', ...args] },

{ language: 'Python', key: '--python', exec: ['python', 'python/test/test.py', ...args] },

{ language: 'Python 2', key: '--python2', exec: ['python2', 'python/test/test.py', ...args] },

{ language: 'Python 3', key: '--python3', exec: ['python3', 'python/test/test_async.py', ...args] },

{ language: 'PHP', key: '--php', exec: ['php', '-f', 'php/test/test.php', ...args] }

]

, selectedTests = allTests.filter (t => keys[t.key])

, scheduledTests = selectedTests.length ? selectedTests : allTests

, completeTests = await sequentialMap (scheduledTests, async test => Object.assign (test, await exec (...test.exec)))

, failed = completeTests.find (test => test.failed)

, hasWarnings = completeTests.find (test => test.hasWarnings)

, warnings = completeTests.reduce ((total, { warnings }) => total.concat (warnings), [])

numExchangesTested++

const percentsDone = ((numExchangesTested / exchanges.length) * 100).toFixed (0) + '%'

log.bright (('[' + percentsDone + ']').dim, 'Testing', exchange.cyan, (failed ? 'FAIL'.red :

(hasWarnings ? (warnings.length ? warnings.join (' ') : 'WARN').yellow

: 'OK'.green)))

return {

exchange,

failed,

hasWarnings,

explain () {

for (const { language, failed, output, hasWarnings } of completeTests) {

if (failed || hasWarnings) {

if (!failed && output.indexOf('[Skipped]') >= 0)

continue;

if (failed) { log.bright ('\nFAILED'.bgBrightRed.white, exchange.red, '(' + language + '):\n') }

else { log.bright ('\nWARN'.yellow.inverse, exchange.yellow, '(' + language + '):\n') }

log.indent (1) (output)

}

}

}

}

const pending = []

, queue = []

let numActive = 0

return {

pending,

run (task) {

if (numActive >= maxConcurrency) { // queue task

return new Promise (resolve => queue.push (() => this.run (task).then (resolve)))

} else { // execute task

let p = task ().then (x => {

numActive--

return (queue.length && (numActive < maxConcurrency))

? queue.shift () ().then (() => x)

: x

})

numActive++

pending.push (p)

return p

}

}

}

const taskPool = TaskPool (maxConcurrency)

const results = []

for (const exchange of exchanges) {

taskPool.run (() => testExchange (exchange).then (x => results.push (x)))

}

await Promise.all (taskPool.pending)

return results