pax_global_header 0000666 0000000 0000000 00000000064 13306334666 0014524 g ustar 00root root 0000000 0000000 52 comment=050b318651f9a5858564e9818482851b35df1c47
tape-4.9.1/ 0000775 0000000 0000000 00000000000 13306334666 0012470 5 ustar 00root root 0000000 0000000 tape-4.9.1/.editorconfig 0000664 0000000 0000000 00000000724 13306334666 0015150 0 ustar 00root root 0000000 0000000 root = true
[*]
indent_style = space
indent_size = 4
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
max_line_length = 140
block_comment_start = /*
block_comment = *
block_comment_end = */
[*.md]
indent_style = space
indent_size = 4
[readme.markdown]
indent_size = off
max_line_length = off
[*.json]
max_line_length = off
[*.yml]
max_line_length = off
[Makefile]
max_line_length = off
[.travis.yml]
indent_size = 2
tape-4.9.1/.eslintrc 0000664 0000000 0000000 00000000114 13306334666 0014310 0 ustar 00root root 0000000 0000000 {
"root": true,
"rules": {
"indent": ["error", 4],
},
}
tape-4.9.1/.gitignore 0000664 0000000 0000000 00000000132 13306334666 0014454 0 ustar 00root root 0000000 0000000 # gitignore
/node_modules
# Only apps should have lockfiles
yarn.lock
package-lock.json
tape-4.9.1/.npmrc 0000664 0000000 0000000 00000000023 13306334666 0013603 0 ustar 00root root 0000000 0000000 package-lock=false
tape-4.9.1/.travis.yml 0000664 0000000 0000000 00000001643 13306334666 0014605 0 ustar 00root root 0000000 0000000 language: node_js
os:
- linux
node_js:
- "10"
- "9"
- "8"
- "7"
- "6"
- "5"
- "4"
- "iojs"
- "0.12"
- "0.10"
- "0.8"
before_install:
- 'case "${TRAVIS_NODE_VERSION}" in 0.*) export NPM_CONFIG_STRICT_SSL=false ;; esac'
- 'nvm install-latest-npm'
install:
- 'if [ "${TRAVIS_NODE_VERSION}" = "0.6" ] || [ "${TRAVIS_NODE_VERSION}" = "0.9" ]; then nvm install --latest-npm 0.8 && npm install && nvm use "${TRAVIS_NODE_VERSION}"; else npm install; fi;'
script:
- 'if [ -n "${PRETEST-}" ]; then npm run pretest ; fi'
- 'if [ -n "${POSTTEST-}" ]; then npm run posttest ; fi'
- 'if [ -n "${COVERAGE-}" ]; then npm run coverage ; fi'
- 'if [ -n "${TEST-}" ]; then npm run tests-only ; fi'
sudo: false
env:
- TEST=true
matrix:
fast_finish: true
include:
- node_js: "lts/*"
env: PRETEST=true
allow_failures:
- node_js: "9"
- node_js: "7"
- node_js: "5"
- node_js: "iojs"
tape-4.9.1/LICENSE 0000664 0000000 0000000 00000002061 13306334666 0013474 0 ustar 00root root 0000000 0000000 This software is released under the MIT license:
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
tape-4.9.1/bin/ 0000775 0000000 0000000 00000000000 13306334666 0013240 5 ustar 00root root 0000000 0000000 tape-4.9.1/bin/tape 0000775 0000000 0000000 00000002211 13306334666 0014113 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
var resolveModule = require('resolve').sync;
var resolvePath = require('path').resolve;
var parseOpts = require('minimist');
var glob = require('glob');
var opts = parseOpts(process.argv.slice(2), {
alias: { r: 'require' },
string: 'require',
default: { r: [] }
});
var cwd = process.cwd();
if (typeof opts.require === 'string') {
opts.require = [opts.require];
}
opts.require.forEach(function(module) {
if (module) {
/* This check ensures we ignore `-r ""`, trailing `-r`, or
* other silly things the user might (inadvertently) be doing.
*/
require(resolveModule(module, { basedir: cwd }));
}
});
opts._.forEach(function (arg) {
// If glob does not match, `files` will be an empty array.
// Note: `glob.sync` may throw an error and crash the node process.
var files = glob.sync(arg);
if (!Array.isArray(files)) {
throw new TypeError('unknown error: glob.sync did not return an array or throw. Please report this.');
}
files.forEach(function (file) {
require(resolvePath(cwd, file));
});
});
// vim: ft=javascript
tape-4.9.1/example/ 0000775 0000000 0000000 00000000000 13306334666 0014123 5 ustar 00root root 0000000 0000000 tape-4.9.1/example/array.js 0000664 0000000 0000000 00000001414 13306334666 0015577 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../');
test('array', function (t) {
t.plan(5);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
tape-4.9.1/example/fail.js 0000664 0000000 0000000 00000001417 13306334666 0015377 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../');
test('array', function (t) {
t.plan(5);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4444 ] ], [ 5, 6 ] ]);
}
);
});
tape-4.9.1/example/nested.js 0000664 0000000 0000000 00000002115 13306334666 0015742 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../');
test('nested array test', function (t) {
t.plan(5);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
t.test('inside test', function (q) {
q.plan(2);
q.ok(true, 'inside ok');
setTimeout(function () {
q.ok(true, 'inside delayed');
}, 3000);
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
test('another', function (t) {
t.plan(1);
setTimeout(function () {
t.ok(true);
}, 100);
});
tape-4.9.1/example/nested_fail.js 0000664 0000000 0000000 00000002061 13306334666 0016735 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../');
test('nested array test', function (t) {
t.plan(5);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
t.test('inside test', function (q) {
q.plan(2);
q.ok(true);
setTimeout(function () {
q.equal(3, 4);
}, 3000);
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
test('another', function (t) {
t.plan(1);
setTimeout(function () {
t.ok(true);
}, 100);
});
tape-4.9.1/example/not_enough.js 0000664 0000000 0000000 00000001414 13306334666 0016626 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../');
test('array', function (t) {
t.plan(8);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
tape-4.9.1/example/static/ 0000775 0000000 0000000 00000000000 13306334666 0015412 5 ustar 00root root 0000000 0000000 tape-4.9.1/example/static/build.sh 0000775 0000000 0000000 00000000061 13306334666 0017045 0 ustar 00root root 0000000 0000000 #!/bin/bash
browserify ../timing.js -o bundle.js
tape-4.9.1/example/static/index.html 0000664 0000000 0000000 00000000542 13306334666 0017410 0 ustar 00root root 0000000 0000000
tape-4.9.1/example/static/server.js 0000664 0000000 0000000 00000000212 13306334666 0017251 0 ustar 00root root 0000000 0000000 var http = require('http');
var ecstatic = require('ecstatic')(__dirname);
var server = http.createServer(ecstatic);
server.listen(8000);
tape-4.9.1/example/stream/ 0000775 0000000 0000000 00000000000 13306334666 0015416 5 ustar 00root root 0000000 0000000 tape-4.9.1/example/stream/object.js 0000664 0000000 0000000 00000000376 13306334666 0017230 0 ustar 00root root 0000000 0000000 var test = require('../../');
var path = require('path');
test.createStream({ objectMode: true }).on('data', function (row) {
console.log(JSON.stringify(row))
});
process.argv.slice(2).forEach(function (file) {
require(path.resolve(file));
});
tape-4.9.1/example/stream/tap.js 0000664 0000000 0000000 00000000273 13306334666 0016542 0 ustar 00root root 0000000 0000000 var test = require('../../');
var path = require('path');
test.createStream().pipe(process.stdout);
process.argv.slice(2).forEach(function (file) {
require(path.resolve(file));
});
tape-4.9.1/example/stream/test/ 0000775 0000000 0000000 00000000000 13306334666 0016375 5 ustar 00root root 0000000 0000000 tape-4.9.1/example/stream/test/x.js 0000664 0000000 0000000 00000000145 13306334666 0017202 0 ustar 00root root 0000000 0000000 var test = require('../../../');
test(function (t) {
t.plan(1);
t.equal('beep', 'boop');
});
tape-4.9.1/example/stream/test/y.js 0000664 0000000 0000000 00000000254 13306334666 0017204 0 ustar 00root root 0000000 0000000 var test = require('../../../');
test(function (t) {
t.plan(2);
t.equal(1+1, 2);
t.ok(true);
});
test('wheee', function (t) {
t.ok(true);
t.end();
});
tape-4.9.1/example/throw.js 0000664 0000000 0000000 00000000272 13306334666 0015625 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../');
test('throw', function (t) {
t.plan(2);
setTimeout(function () {
throw new Error('doom');
}, 100);
});
tape-4.9.1/example/timing.js 0000664 0000000 0000000 00000000352 13306334666 0015750 0 ustar 00root root 0000000 0000000 var test = require('../');
test('timing test', function (t) {
t.plan(2);
t.equal(typeof Date.now, 'function');
var start = new Date;
setTimeout(function () {
t.equal(new Date - start, 100);
}, 100);
});
tape-4.9.1/example/too_many.js 0000664 0000000 0000000 00000001414 13306334666 0016306 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../');
test('array', function (t) {
t.plan(3);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
tape-4.9.1/example/two.js 0000664 0000000 0000000 00000000506 13306334666 0015273 0 ustar 00root root 0000000 0000000 var test = require('../');
test('one', function (t) {
t.plan(2);
t.ok(true);
setTimeout(function () {
t.equal(1+3, 4);
}, 100);
});
test('two', function (t) {
t.plan(3);
t.equal(5, 2+3);
setTimeout(function () {
t.equal('a'.charCodeAt(0), 97);
t.ok(true);
}, 50);
});
tape-4.9.1/index.js 0000664 0000000 0000000 00000007771 13306334666 0014151 0 ustar 00root root 0000000 0000000 var defined = require('defined');
var createDefaultStream = require('./lib/default_stream');
var Test = require('./lib/test');
var createResult = require('./lib/results');
var through = require('through');
var canEmitExit = typeof process !== 'undefined' && process
&& typeof process.on === 'function' && process.browser !== true
;
var canExit = typeof process !== 'undefined' && process
&& typeof process.exit === 'function'
;
var nextTick = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick
;
exports = module.exports = (function () {
var harness;
var lazyLoad = function () {
return getHarness().apply(this, arguments);
};
lazyLoad.only = function () {
return getHarness().only.apply(this, arguments);
};
lazyLoad.createStream = function (opts) {
if (!opts) opts = {};
if (!harness) {
var output = through();
getHarness({ stream: output, objectMode: opts.objectMode });
return output;
}
return harness.createStream(opts);
};
lazyLoad.onFinish = function () {
return getHarness().onFinish.apply(this, arguments);
};
lazyLoad.onFailure = function() {
return getHarness().onFailure.apply(this, arguments);
};
lazyLoad.getHarness = getHarness
return lazyLoad
function getHarness (opts) {
if (!opts) opts = {};
opts.autoclose = !canEmitExit;
if (!harness) harness = createExitHarness(opts);
return harness;
}
})();
function createExitHarness (conf) {
if (!conf) conf = {};
var harness = createHarness({
autoclose: defined(conf.autoclose, false)
});
var stream = harness.createStream({ objectMode: conf.objectMode });
var es = stream.pipe(conf.stream || createDefaultStream());
if (canEmitExit) {
es.on('error', function (err) { harness._exitCode = 1 });
}
var ended = false;
stream.on('end', function () { ended = true });
if (conf.exit === false) return harness;
if (!canEmitExit || !canExit) return harness;
var inErrorState = false;
process.on('exit', function (code) {
// let the process exit cleanly.
if (code !== 0) {
return
}
if (!ended) {
var only = harness._results._only;
for (var i = 0; i < harness._tests.length; i++) {
var t = harness._tests[i];
if (only && t !== only) continue;
t._exit();
}
}
harness.close();
process.exit(code || harness._exitCode);
});
return harness;
}
exports.createHarness = createHarness;
exports.Test = Test;
exports.test = exports; // tap compat
exports.test.skip = Test.skip;
var exitInterval;
function createHarness (conf_) {
if (!conf_) conf_ = {};
var results = createResult();
if (conf_.autoclose !== false) {
results.once('done', function () { results.close() });
}
var test = function (name, conf, cb) {
var t = new Test(name, conf, cb);
test._tests.push(t);
(function inspectCode (st) {
st.on('test', function sub (st_) {
inspectCode(st_);
});
st.on('result', function (r) {
if (!r.ok && typeof r !== 'string') test._exitCode = 1
});
})(t);
results.push(t);
return t;
};
test._results = results;
test._tests = [];
test.createStream = function (opts) {
return results.createStream(opts);
};
test.onFinish = function (cb) {
results.on('done', cb);
};
test.onFailure = function (cb) {
results.on('fail', cb);
};
var only = false;
test.only = function () {
if (only) throw new Error('there can only be one only test');
only = true;
var t = test.apply(null, arguments);
results.only(t);
return t;
};
test._exitCode = 0;
test.close = function () { results.close() };
return test;
}
tape-4.9.1/lib/ 0000775 0000000 0000000 00000000000 13306334666 0013236 5 ustar 00root root 0000000 0000000 tape-4.9.1/lib/default_stream.js 0000664 0000000 0000000 00000001425 13306334666 0016575 0 ustar 00root root 0000000 0000000 var through = require('through');
var fs = require('fs');
module.exports = function () {
var line = '';
var stream = through(write, flush);
return stream;
function write (buf) {
for (var i = 0; i < buf.length; i++) {
var c = typeof buf === 'string'
? buf.charAt(i)
: String.fromCharCode(buf[i])
;
if (c === '\n') flush();
else line += c;
}
}
function flush () {
if (fs.writeSync && /^win/.test(process.platform)) {
try { fs.writeSync(1, line + '\n'); }
catch (e) { stream.emit('error', e) }
} else {
try { console.log(line) }
catch (e) { stream.emit('error', e) }
}
line = '';
}
};
tape-4.9.1/lib/results.js 0000664 0000000 0000000 00000012570 13306334666 0015302 0 ustar 00root root 0000000 0000000 var defined = require('defined');
var EventEmitter = require('events').EventEmitter;
var inherits = require('inherits');
var through = require('through');
var resumer = require('resumer');
var inspect = require('object-inspect');
var bind = require('function-bind');
var has = require('has');
var regexpTest = bind.call(Function.call, RegExp.prototype.test);
var yamlIndicators = /\:|\-|\?/;
var nextTick = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick
;
module.exports = Results;
inherits(Results, EventEmitter);
function Results () {
if (!(this instanceof Results)) return new Results;
this.count = 0;
this.fail = 0;
this.pass = 0;
this._stream = through();
this.tests = [];
this._only = null;
}
Results.prototype.createStream = function (opts) {
if (!opts) opts = {};
var self = this;
var output, testId = 0;
if (opts.objectMode) {
output = through();
self.on('_push', function ontest (t, extra) {
if (!extra) extra = {};
var id = testId++;
t.once('prerun', function () {
var row = {
type: 'test',
name: t.name,
id: id
};
if (has(extra, 'parent')) {
row.parent = extra.parent;
}
output.queue(row);
});
t.on('test', function (st) {
ontest(st, { parent: id });
});
t.on('result', function (res) {
res.test = id;
res.type = 'assert';
output.queue(res);
});
t.on('end', function () {
output.queue({ type: 'end', test: id });
});
});
self.on('done', function () { output.queue(null) });
} else {
output = resumer();
output.queue('TAP version 13\n');
self._stream.pipe(output);
}
nextTick(function next() {
var t;
while (t = getNextTest(self)) {
t.run();
if (!t.ended) return t.once('end', function(){ nextTick(next); });
}
self.emit('done');
});
return output;
};
Results.prototype.push = function (t) {
var self = this;
self.tests.push(t);
self._watch(t);
self.emit('_push', t);
};
Results.prototype.only = function (t) {
this._only = t;
};
Results.prototype._watch = function (t) {
var self = this;
var write = function (s) { self._stream.queue(s) };
t.once('prerun', function () {
write('# ' + t.name + '\n');
});
t.on('result', function (res) {
if (typeof res === 'string') {
write('# ' + res + '\n');
return;
}
write(encodeResult(res, self.count + 1));
self.count ++;
if (res.ok) self.pass ++
else {
self.fail ++;
self.emit('fail');
}
});
t.on('test', function (st) { self._watch(st) });
};
Results.prototype.close = function () {
var self = this;
if (self.closed) self._stream.emit('error', new Error('ALREADY CLOSED'));
self.closed = true;
var write = function (s) { self._stream.queue(s) };
write('\n1..' + self.count + '\n');
write('# tests ' + self.count + '\n');
write('# pass ' + self.pass + '\n');
if (self.fail) write('# fail ' + self.fail + '\n')
else write('\n# ok\n')
self._stream.queue(null);
};
function encodeResult (res, count) {
var output = '';
output += (res.ok ? 'ok ' : 'not ok ') + count;
output += res.name ? ' ' + res.name.toString().replace(/\s+/g, ' ') : '';
if (res.skip) output += ' # SKIP';
else if (res.todo) output += ' # TODO';
output += '\n';
if (res.ok) return output;
var outer = ' ';
var inner = outer + ' ';
output += outer + '---\n';
output += inner + 'operator: ' + res.operator + '\n';
if (has(res, 'expected') || has(res, 'actual')) {
var ex = inspect(res.expected, {depth: res.objectPrintDepth});
var ac = inspect(res.actual, {depth: res.objectPrintDepth});
if (Math.max(ex.length, ac.length) > 65 || invalidYaml(ex) || invalidYaml(ac)) {
output += inner + 'expected: |-\n' + inner + ' ' + ex + '\n';
output += inner + 'actual: |-\n' + inner + ' ' + ac + '\n';
} else {
output += inner + 'expected: ' + ex + '\n';
output += inner + 'actual: ' + ac + '\n';
}
}
if (res.at) {
output += inner + 'at: ' + res.at + '\n';
}
var actualStack = res.actual && (typeof res.actual === 'object' || typeof res.actual === 'function') ? res.actual.stack : undefined;
var errorStack = res.error && res.error.stack;
var stack = defined(actualStack, errorStack);
if (stack) {
var lines = String(stack).split('\n');
output += inner + 'stack: |-\n';
for (var i = 0; i < lines.length; i++) {
output += inner + ' ' + lines[i] + '\n';
}
}
output += outer + '...\n';
return output;
}
function getNextTest (results) {
if (!results._only) {
return results.tests.shift();
}
do {
var t = results.tests.shift();
if (!t) continue;
if (results._only === t) {
return t;
}
} while (results.tests.length !== 0)
}
function invalidYaml (str) {
return regexpTest(yamlIndicators, str);
}
tape-4.9.1/lib/test.js 0000664 0000000 0000000 00000035121 13306334666 0014555 0 ustar 00root root 0000000 0000000 var deepEqual = require('deep-equal');
var defined = require('defined');
var path = require('path');
var inherits = require('inherits');
var EventEmitter = require('events').EventEmitter;
var has = require('has');
var trim = require('string.prototype.trim');
var bind = require('function-bind');
var forEach = require('for-each');
var isEnumerable = bind.call(Function.call, Object.prototype.propertyIsEnumerable);
var toLowerCase = bind.call(Function.call, String.prototype.toLowerCase);
module.exports = Test;
var nextTick = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick;
var safeSetTimeout = setTimeout;
var safeClearTimeout = clearTimeout;
inherits(Test, EventEmitter);
var getTestArgs = function (name_, opts_, cb_) {
var name = '(anonymous)';
var opts = {};
var cb;
for (var i = 0; i < arguments.length; i++) {
var arg = arguments[i];
var t = typeof arg;
if (t === 'string') {
name = arg;
} else if (t === 'object') {
opts = arg || opts;
} else if (t === 'function') {
cb = arg;
}
}
return { name: name, opts: opts, cb: cb };
};
function Test (name_, opts_, cb_) {
if (! (this instanceof Test)) {
return new Test(name_, opts_, cb_);
}
var args = getTestArgs(name_, opts_, cb_);
this.readable = true;
this.name = args.name || '(anonymous)';
this.assertCount = 0;
this.pendingCount = 0;
this._skip = args.opts.skip || false;
this._timeout = args.opts.timeout;
this._plan = undefined;
this._cb = args.cb;
this._progeny = [];
this._ok = true;
var depthEnvVar = process.env.NODE_TAPE_OBJECT_PRINT_DEPTH;
if (args.opts.objectPrintDepth) {
this._objectPrintDepth = args.opts.objectPrintDepth;
} else if (depthEnvVar) {
if (toLowerCase(depthEnvVar) === 'infinity') {
this._objectPrintDepth = Infinity;
} else {
this._objectPrintDepth = depthEnvVar;
}
} else {
this._objectPrintDepth = 5;
}
for (var prop in this) {
this[prop] = (function bind(self, val) {
if (typeof val === 'function') {
return function bound() {
return val.apply(self, arguments);
};
}
return val;
})(this, this[prop]);
}
}
Test.prototype.run = function () {
if (this._skip) {
this.comment('SKIP ' + this.name);
}
if (!this._cb || this._skip) {
return this._end();
}
if (this._timeout != null) {
this.timeoutAfter(this._timeout);
}
this.emit('prerun');
this._cb(this);
this.emit('run');
};
Test.prototype.test = function (name, opts, cb) {
var self = this;
var t = new Test(name, opts, cb);
this._progeny.push(t);
this.pendingCount++;
this.emit('test', t);
t.on('prerun', function () {
self.assertCount++;
})
if (!self._pendingAsserts()) {
nextTick(function () {
self._end();
});
}
nextTick(function() {
if (!self._plan && self.pendingCount == self._progeny.length) {
self._end();
}
});
};
Test.prototype.comment = function (msg) {
var that = this;
forEach(trim(msg).split('\n'), function (aMsg) {
that.emit('result', trim(aMsg).replace(/^#\s*/, ''));
});
};
Test.prototype.plan = function (n) {
this._plan = n;
this.emit('plan', n);
};
Test.prototype.timeoutAfter = function(ms) {
if (!ms) throw new Error('timeoutAfter requires a timespan');
var self = this;
var timeout = safeSetTimeout(function() {
self.fail('test timed out after ' + ms + 'ms');
self.end();
}, ms);
this.once('end', function() {
safeClearTimeout(timeout);
});
}
Test.prototype.end = function (err) {
var self = this;
if (arguments.length >= 1 && !!err) {
this.ifError(err);
}
if (this.calledEnd) {
this.fail('.end() called twice');
}
this.calledEnd = true;
this._end();
};
Test.prototype._end = function (err) {
var self = this;
if (this._progeny.length) {
var t = this._progeny.shift();
t.on('end', function () { self._end() });
t.run();
return;
}
if (!this.ended) this.emit('end');
var pendingAsserts = this._pendingAsserts();
if (!this._planError && this._plan !== undefined && pendingAsserts) {
this._planError = true;
this.fail('plan != count', {
expected : this._plan,
actual : this.assertCount
});
}
this.ended = true;
};
Test.prototype._exit = function () {
if (this._plan !== undefined &&
!this._planError && this.assertCount !== this._plan) {
this._planError = true;
this.fail('plan != count', {
expected : this._plan,
actual : this.assertCount,
exiting : true
});
} else if (!this.ended) {
this.fail('test exited without ending', {
exiting: true
});
}
};
Test.prototype._pendingAsserts = function () {
if (this._plan === undefined) {
return 1;
}
return this._plan - (this._progeny.length + this.assertCount);
};
Test.prototype._assert = function assert (ok, opts) {
var self = this;
var extra = opts.extra || {};
var res = {
id : self.assertCount ++,
ok : Boolean(ok),
skip : defined(extra.skip, opts.skip),
name : defined(extra.message, opts.message, '(unnamed assert)'),
operator : defined(extra.operator, opts.operator),
objectPrintDepth : self._objectPrintDepth
};
if (has(opts, 'actual') || has(extra, 'actual')) {
res.actual = defined(extra.actual, opts.actual);
}
if (has(opts, 'expected') || has(extra, 'expected')) {
res.expected = defined(extra.expected, opts.expected);
}
this._ok = Boolean(this._ok && ok);
if (!ok) {
res.error = defined(extra.error, opts.error, new Error(res.name));
}
if (!ok) {
var e = new Error('exception');
var err = (e.stack || '').split('\n');
var dir = __dirname + path.sep;
for (var i = 0; i < err.length; i++) {
/*
Stack trace lines may resemble one of the following. We need
to should correctly extract a function name (if any) and
path / line no. for each line.
at myFunction (/path/to/file.js:123:45)
at myFunction (/path/to/file.other-ext:123:45)
at myFunction (/path to/file.js:123:45)
at myFunction (C:\path\to\file.js:123:45)
at myFunction (/path/to/file.js:123)
at Test. (/path/to/file.js:123:45)
at Test.bound [as run] (/path/to/file.js:123:45)
at /path/to/file.js:123:45
Regex has three parts. First is non-capturing group for 'at '
(plus anything preceding it).
/^(?:[^\s]*\s*\bat\s+)/
Second captures function call description (optional). This is
not necessarily a valid JS function name, but just what the
stack trace is using to represent a function call. It may look
like `` or 'Test.bound [as run]'.
For our purposes, we assume that, if there is a function
name, it's everything leading up to the first open
parentheses (trimmed) before our pathname.
/(?:(.*)\s+\()?/
Last part captures file path plus line no (and optional
column no).
/((?:\/|[A-Z]:\\)[^:\)]+:(\d+)(?::(\d+))?)/
*/
var re = /^(?:[^\s]*\s*\bat\s+)(?:(.*)\s+\()?((?:\/|[A-Z]:\\)[^:\)]+:(\d+)(?::(\d+))?)/
var m = re.exec(err[i]);
if (!m) {
continue;
}
var callDescription = m[1] || '';
var filePath = m[2];
if (filePath.slice(0, dir.length) === dir) {
continue;
}
// Function call description may not (just) be a function name.
// Try to extract function name by looking at first "word" only.
res.functionName = callDescription.split(/\s+/)[0]
res.file = filePath;
res.line = Number(m[3]);
if (m[4]) res.column = Number(m[4]);
res.at = callDescription + ' (' + filePath + ')';
break;
}
}
self.emit('result', res);
var pendingAsserts = self._pendingAsserts();
if (!pendingAsserts) {
if (extra.exiting) {
self._end();
} else {
nextTick(function () {
self._end();
});
}
}
if (!self._planError && pendingAsserts < 0) {
self._planError = true;
self.fail('plan != count', {
expected : self._plan,
actual : self._plan - pendingAsserts
});
}
};
Test.prototype.fail = function (msg, extra) {
this._assert(false, {
message : msg,
operator : 'fail',
extra : extra
});
};
Test.prototype.pass = function (msg, extra) {
this._assert(true, {
message : msg,
operator : 'pass',
extra : extra
});
};
Test.prototype.skip = function (msg, extra) {
this._assert(true, {
message : msg,
operator : 'skip',
skip : true,
extra : extra
});
};
function assert(value, msg, extra) {
this._assert(value, {
message : defined(msg, 'should be truthy'),
operator : 'ok',
expected : true,
actual : value,
extra : extra
});
}
Test.prototype.ok
= Test.prototype['true']
= Test.prototype.assert
= assert;
function notOK(value, msg, extra) {
this._assert(!value, {
message : defined(msg, 'should be falsy'),
operator : 'notOk',
expected : false,
actual : value,
extra : extra
});
}
Test.prototype.notOk
= Test.prototype['false']
= Test.prototype.notok
= notOK;
function error(err, msg, extra) {
this._assert(!err, {
message : defined(msg, String(err)),
operator : 'error',
actual : err,
extra : extra
});
}
Test.prototype.error
= Test.prototype.ifError
= Test.prototype.ifErr
= Test.prototype.iferror
= error;
function equal(a, b, msg, extra) {
this._assert(a === b, {
message : defined(msg, 'should be equal'),
operator : 'equal',
actual : a,
expected : b,
extra : extra
});
}
Test.prototype.equal
= Test.prototype.equals
= Test.prototype.isEqual
= Test.prototype.is
= Test.prototype.strictEqual
= Test.prototype.strictEquals
= equal;
function notEqual(a, b, msg, extra) {
this._assert(a !== b, {
message : defined(msg, 'should not be equal'),
operator : 'notEqual',
actual : a,
notExpected : b,
extra : extra
});
}
Test.prototype.notEqual
= Test.prototype.notEquals
= Test.prototype.notStrictEqual
= Test.prototype.notStrictEquals
= Test.prototype.isNotEqual
= Test.prototype.isNot
= Test.prototype.not
= Test.prototype.doesNotEqual
= Test.prototype.isInequal
= notEqual;
function tapeDeepEqual(a, b, msg, extra) {
this._assert(deepEqual(a, b, { strict: true }), {
message : defined(msg, 'should be equivalent'),
operator : 'deepEqual',
actual : a,
expected : b,
extra : extra
});
}
Test.prototype.deepEqual
= Test.prototype.deepEquals
= Test.prototype.isEquivalent
= Test.prototype.same
= tapeDeepEqual;
function deepLooseEqual(a, b, msg, extra) {
this._assert(deepEqual(a, b), {
message : defined(msg, 'should be equivalent'),
operator : 'deepLooseEqual',
actual : a,
expected : b,
extra : extra
});
}
Test.prototype.deepLooseEqual
= Test.prototype.looseEqual
= Test.prototype.looseEquals
= deepLooseEqual;
function notDeepEqual(a, b, msg, extra) {
this._assert(!deepEqual(a, b, { strict: true }), {
message : defined(msg, 'should not be equivalent'),
operator : 'notDeepEqual',
actual : a,
notExpected : b,
extra : extra
});
}
Test.prototype.notDeepEqual
= Test.prototype.notEquivalent
= Test.prototype.notDeeply
= Test.prototype.notSame
= Test.prototype.isNotDeepEqual
= Test.prototype.isNotDeeply
= Test.prototype.isNotEquivalent
= Test.prototype.isInequivalent
= notDeepEqual;
function notDeepLooseEqual(a, b, msg, extra) {
this._assert(!deepEqual(a, b), {
message : defined(msg, 'should be equivalent'),
operator : 'notDeepLooseEqual',
actual : a,
expected : b,
extra : extra
});
}
Test.prototype.notDeepLooseEqual
= Test.prototype.notLooseEqual
= Test.prototype.notLooseEquals
= notDeepLooseEqual;
Test.prototype['throws'] = function (fn, expected, msg, extra) {
if (typeof expected === 'string') {
msg = expected;
expected = undefined;
}
var caught = undefined;
try {
fn();
} catch (err) {
caught = { error : err };
if ((err != null) && (!isEnumerable(err, 'message') || !has(err, 'message'))) {
var message = err.message;
delete err.message;
err.message = message;
}
}
var passed = caught;
if (expected instanceof RegExp) {
passed = expected.test(caught && caught.error);
expected = String(expected);
}
if (typeof expected === 'function' && caught) {
passed = caught.error instanceof expected;
caught.error = caught.error.constructor;
}
this._assert(typeof fn === 'function' && passed, {
message : defined(msg, 'should throw'),
operator : 'throws',
actual : caught && caught.error,
expected : expected,
error: !passed && caught && caught.error,
extra : extra
});
};
Test.prototype.doesNotThrow = function (fn, expected, msg, extra) {
if (typeof expected === 'string') {
msg = expected;
expected = undefined;
}
var caught = undefined;
try {
fn();
}
catch (err) {
caught = { error : err };
}
this._assert(!caught, {
message : defined(msg, 'should not throw'),
operator : 'throws',
actual : caught && caught.error,
expected : expected,
error : caught && caught.error,
extra : extra
});
};
Test.skip = function (name_, _opts, _cb) {
var args = getTestArgs.apply(null, arguments);
args.opts.skip = true;
return Test(args.name, args.opts, args.cb);
};
// vim: set softtabstop=4 shiftwidth=4:
tape-4.9.1/package.json 0000664 0000000 0000000 00000003451 13306334666 0014761 0 ustar 00root root 0000000 0000000 {
"name": "tape",
"version": "4.9.1",
"description": "tap-producing test harness for node and browsers",
"main": "index.js",
"bin": "./bin/tape",
"directories": {
"example": "example",
"test": "test"
},
"dependencies": {
"deep-equal": "~1.0.1",
"defined": "~1.0.0",
"for-each": "~0.3.3",
"function-bind": "~1.1.1",
"glob": "~7.1.2",
"has": "~1.0.3",
"inherits": "~2.0.3",
"minimist": "~1.2.0",
"object-inspect": "~1.6.0",
"resolve": "~1.7.1",
"resumer": "~0.0.0",
"string.prototype.trim": "~1.1.2",
"through": "~2.3.8"
},
"devDependencies": {
"concat-stream": "^1.6.2",
"eclint": "^2.7.0",
"eslint": "^4.19.1",
"falafel": "^2.1.0",
"js-yaml": "^3.12.0",
"tap": "^8.0.1",
"tap-parser": "^3.0.5"
},
"scripts": {
"prelint": "eclint check",
"lint": "eslint .",
"pretest": "npm run lint",
"test": "npm run tests-only",
"tests-only": "tap test/*.js"
},
"testling": {
"files": "test/browser/*.js",
"browsers": [
"ie/6..latest",
"chrome/20..latest",
"firefox/10..latest",
"safari/latest",
"opera/11.0..latest",
"iphone/6",
"ipad/6"
]
},
"repository": {
"type": "git",
"url": "git://github.com/substack/tape.git"
},
"homepage": "https://github.com/substack/tape",
"keywords": [
"tap",
"test",
"harness",
"assert",
"browser"
],
"author": {
"name": "James Halliday",
"email": "mail@substack.net",
"url": "http://substack.net"
},
"license": "MIT"
}
tape-4.9.1/readme.markdown 0000664 0000000 0000000 00000030276 13306334666 0015501 0 ustar 00root root 0000000 0000000 # tape
tap-producing test harness for node and browsers
[](http://ci.testling.com/substack/tape)
[](http://travis-ci.org/substack/tape)
# example
``` js
var test = require('tape');
test('timing test', function (t) {
t.plan(2);
t.equal(typeof Date.now, 'function');
var start = Date.now();
setTimeout(function () {
t.equal(Date.now() - start, 100);
}, 100);
});
```
```
$ node example/timing.js
TAP version 13
# timing test
ok 1 should be equal
not ok 2 should be equal
---
operator: equal
expected: 100
actual: 107
...
1..2
# tests 2
# pass 1
# fail 1
```
# usage
You always need to `require('tape')` in test files. You can run the tests by
usual node means (`require('test-file.js')` or `node test-file.js`). You can
also run tests using the `tape` binary to utilize globbing, on Windows for
example:
```sh
$ tape tests/**/*.js
```
`tape`'s arguments are passed to the
[`glob`](https://www.npmjs.com/package/glob) module. If you want `glob` to
perform the expansion on a system where the shell performs such expansion, quote
the arguments as necessary:
```sh
$ tape 'tests/**/*.js'
$ tape "tests/**/*.js"
```
## Preloading modules
Additionally, it is possible to make `tape` load one or more modules before running any tests, by using the `-r` or `--require` flag. Here's an example that loads [babel-register](http://babeljs.io/docs/usage/require/) before running any tests, to allow for JIT compilation:
```sh
$ tape -r babel-register tests/**/*.js
```
Depending on the module you're loading, you may be able to parameterize it using environment variables or auxiliary files. Babel, for instance, will load options from [`.babelrc`](http://babeljs.io/docs/usage/babelrc/) at runtime.
The `-r` flag behaves exactly like node's `require`, and uses the same module resolution algorithm. This means that if you need to load local modules, you have to prepend their path with `./` or `../` accordingly.
For example:
```sh
$ tape -r ./my/local/module tests/**/*.js
```
Please note that all modules loaded using the `-r` flag will run *before* any tests, regardless of when they are specified. For example, `tape -r a b -r c` will actually load `a` and `c` *before* loading `b`, since they are flagged as required modules.
# things that go well with tape
tape maintains a fairly minimal core. Additional features are usually added by using another module alongside tape.
## pretty reporters
The default TAP output is good for machines and humans that are robots.
If you want a more colorful / pretty output there are lots of modules on npm
that will output something pretty if you pipe TAP into them:
- https://github.com/scottcorgan/tap-spec
- https://github.com/scottcorgan/tap-dot
- https://github.com/substack/faucet
- https://github.com/juliangruber/tap-bail
- https://github.com/kirbysayshi/tap-browser-color
- https://github.com/gummesson/tap-json
- https://github.com/derhuerst/tap-min
- https://github.com/calvinmetcalf/tap-nyan
- https://www.npmjs.org/package/tap-pessimist
- https://github.com/toolness/tap-prettify
- https://github.com/shuhei/colortape
- https://github.com/aghassemi/tap-xunit
- https://github.com/namuol/tap-difflet
- https://github.com/gritzko/tape-dom
- https://github.com/axross/tap-diff
- https://github.com/axross/tap-notify
- https://github.com/zoubin/tap-summary
- https://github.com/Hypercubed/tap-markdown
- https://github.com/gabrielcsapo/tap-html
- https://github.com/mcnuttandrew/tap-react-browser
To use them, try `node test/index.js | tap-spec` or pipe it into one
of the modules of your choice!
## uncaught exceptions
By default, uncaught exceptions in your tests will not be intercepted, and will cause tape to crash. If you find this behavior undesirable, use [tape-catch](https://github.com/michaelrhodes/tape-catch) to report any exceptions as TAP errors.
## other
- CoffeeScript support with https://www.npmjs.com/package/coffeetape
- Promise support with https://www.npmjs.com/package/blue-tape
- ES6 support with https://www.npmjs.com/package/babel-tape-runner
# methods
The assertion methods in tape are heavily influenced or copied from the methods
in [node-tap](https://github.com/isaacs/node-tap).
```
var test = require('tape')
```
## test([name], [opts], cb)
Create a new test with an optional `name` string and optional `opts` object.
`cb(t)` fires with the new test object `t` once all preceding tests have
finished. Tests execute serially.
Available `opts` options are:
- opts.skip = true/false. See test.skip.
- opts.timeout = 500. Set a timeout for the test, after which it will fail. See test.timeoutAfter.
- opts.objectPrintDepth = 5. Configure max depth of expected / actual object printing. Environmental variable `NODE_TAPE_OBJECT_PRINT_DEPTH` can set the desired default depth for all tests; locally-set values will take precedence.
If you forget to `t.plan()` out how many assertions you are going to run and you
don't call `t.end()` explicitly, your test will hang.
## test.skip(name, cb)
Generate a new test that will be skipped over.
## test.onFinish(fn)
The onFinish hook will get invoked when ALL tape tests have finished
right before tape is about to print the test summary.
## test.onFailure(fn)
The onFailure hook will get invoked whenever any tape tests has failed.
## t.plan(n)
Declare that `n` assertions should be run. `t.end()` will be called
automatically after the `n`th assertion. If there are any more assertions after
the `n`th, or after `t.end()` is called, they will generate errors.
## t.end(err)
Declare the end of a test explicitly. If `err` is passed in `t.end` will assert
that it is falsey.
## t.fail(msg)
Generate a failing assertion with a message `msg`.
## t.pass(msg)
Generate a passing assertion with a message `msg`.
## t.timeoutAfter(ms)
Automatically timeout the test after X ms.
## t.skip(msg)
Generate an assertion that will be skipped over.
## t.ok(value, msg)
Assert that `value` is truthy with an optional description of the assertion `msg`.
Aliases: `t.true()`, `t.assert()`
## t.notOk(value, msg)
Assert that `value` is falsy with an optional description of the assertion `msg`.
Aliases: `t.false()`, `t.notok()`
## t.error(err, msg)
Assert that `err` is falsy. If `err` is non-falsy, use its `err.message` as the
description message.
Aliases: `t.ifError()`, `t.ifErr()`, `t.iferror()`
## t.equal(actual, expected, msg)
Assert that `actual === expected` with an optional description of the assertion `msg`.
Aliases: `t.equals()`, `t.isEqual()`, `t.is()`, `t.strictEqual()`,
`t.strictEquals()`
## t.notEqual(actual, expected, msg)
Assert that `actual !== expected` with an optional description of the assertion `msg`.
Aliases: `t.notEquals()`, `t.notStrictEqual()`, `t.notStrictEquals()`,
`t.isNotEqual()`, `t.isNot()`, `t.not()`, `t.doesNotEqual()`, `t.isInequal()`
## t.deepEqual(actual, expected, msg)
Assert that `actual` and `expected` have the same structure and nested values using
[node's deepEqual() algorithm](https://github.com/substack/node-deep-equal)
with strict comparisons (`===`) on leaf nodes and an optional description of the assertion `msg`.
Aliases: `t.deepEquals()`, `t.isEquivalent()`, `t.same()`
## t.notDeepEqual(actual, expected, msg)
Assert that `actual` and `expected` do not have the same structure and nested values using
[node's deepEqual() algorithm](https://github.com/substack/node-deep-equal)
with strict comparisons (`===`) on leaf nodes and an optional description of the assertion `msg`.
Aliases: `t.notEquivalent()`, `t.notDeeply()`, `t.notSame()`,
`t.isNotDeepEqual()`, `t.isNotDeeply()`, `t.isNotEquivalent()`,
`t.isInequivalent()`
## t.deepLooseEqual(actual, expected, msg)
Assert that `actual` and `expected` have the same structure and nested values using
[node's deepEqual() algorithm](https://github.com/substack/node-deep-equal)
with loose comparisons (`==`) on leaf nodes and an optional description of the assertion `msg`.
Aliases: `t.looseEqual()`, `t.looseEquals()`
## t.notDeepLooseEqual(actual, expected, msg)
Assert that `actual` and `expected` do not have the same structure and nested values using
[node's deepEqual() algorithm](https://github.com/substack/node-deep-equal)
with loose comparisons (`==`) on leaf nodes and an optional description of the assertion `msg`.
Aliases: `t.notLooseEqual()`, `t.notLooseEquals()`
## t.throws(fn, expected, msg)
Assert that the function call `fn()` throws an exception. `expected`, if present, must be a `RegExp` or `Function`. The `RegExp` matches the string representation of the exception, as generated by `err.toString()`. The `Function` is the exception thrown (e.g. `Error`). `msg` is an optional description of the assertion.
## t.doesNotThrow(fn, expected, msg)
Assert that the function call `fn()` does not throw an exception. `msg` is an optional description of the assertion.
## t.test(name, [opts], cb)
Create a subtest with a new test handle `st` from `cb(st)` inside the current
test `t`. `cb(st)` will only fire when `t` finishes. Additional tests queued up
after `t` will not be run until all subtests finish.
You may pass the same options that [`test()`](#testname-opts-cb) accepts.
## t.comment(message)
Print a message without breaking the tap output. (Useful when using e.g. `tap-colorize` where output is buffered & `console.log` will print in incorrect order vis-a-vis tap output.)
## var htest = test.createHarness()
Create a new test harness instance, which is a function like `test()`, but with
a new pending stack and test state.
By default the TAP output goes to `console.log()`. You can pipe the output to
someplace else if you `htest.createStream().pipe()` to a destination stream on
the first tick.
## test.only(name, cb)
Like `test(name, cb)` except if you use `.only` this is the only test case
that will run for the entire process, all other test cases using tape will
be ignored
## var stream = test.createStream(opts)
Create a stream of output, bypassing the default output stream that writes
messages to `console.log()`. By default `stream` will be a text stream of TAP
output, but you can get an object stream instead by setting `opts.objectMode` to
`true`.
### tap stream reporter
You can create your own custom test reporter using this `createStream()` api:
``` js
var test = require('tape');
var path = require('path');
test.createStream().pipe(process.stdout);
process.argv.slice(2).forEach(function (file) {
require(path.resolve(file));
});
```
You could substitute `process.stdout` for whatever other output stream you want,
like a network connection or a file.
Pass in test files to run as arguments:
```
$ node tap.js test/x.js test/y.js
TAP version 13
# (anonymous)
not ok 1 should be equal
---
operator: equal
expected: "boop"
actual: "beep"
...
# (anonymous)
ok 2 should be equal
ok 3 (unnamed assert)
# wheee
ok 4 (unnamed assert)
1..4
# tests 4
# pass 3
# fail 1
```
### object stream reporter
Here's how you can render an object stream instead of TAP:
``` js
var test = require('tape');
var path = require('path');
test.createStream({ objectMode: true }).on('data', function (row) {
console.log(JSON.stringify(row))
});
process.argv.slice(2).forEach(function (file) {
require(path.resolve(file));
});
```
The output for this runner is:
```
$ node object.js test/x.js test/y.js
{"type":"test","name":"(anonymous)","id":0}
{"id":0,"ok":false,"name":"should be equal","operator":"equal","actual":"beep","expected":"boop","error":{},"test":0,"type":"assert"}
{"type":"end","test":0}
{"type":"test","name":"(anonymous)","id":1}
{"id":0,"ok":true,"name":"should be equal","operator":"equal","actual":2,"expected":2,"test":1,"type":"assert"}
{"id":1,"ok":true,"name":"(unnamed assert)","operator":"ok","actual":true,"expected":true,"test":1,"type":"assert"}
{"type":"end","test":1}
{"type":"test","name":"wheee","id":2}
{"id":0,"ok":true,"name":"(unnamed assert)","operator":"ok","actual":true,"expected":true,"test":2,"type":"assert"}
{"type":"end","test":2}
```
# install
With [npm](https://npmjs.org) do:
```
npm install tape --save-dev
```
# license
MIT
tape-4.9.1/test/ 0000775 0000000 0000000 00000000000 13306334666 0013447 5 ustar 00root root 0000000 0000000 tape-4.9.1/test/add-subtest-async.js 0000664 0000000 0000000 00000000340 13306334666 0017334 0 ustar 00root root 0000000 0000000 var test = require('../')
test('parent', function (t) {
t.pass('parent');
setTimeout(function () {
t.test('child', function (t) {
t.pass('child');
t.end();
});
}, 100)
})
tape-4.9.1/test/anonymous-fn.js 0000664 0000000 0000000 00000002666 13306334666 0016450 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
var testWrapper = require('./anonymous-fn/test-wrapper');
tap.test('inside anonymous functions', function (tt) {
tt.plan(1);
var test = tape.createHarness();
var tc = function (rows) {
var body = stripFullStack(rows.toString('utf8'));
// Handle stack trace variation in Node v0.8
body = body.replace(
'at Test.module.exports',
'at Test.'
);
tt.same(body, [
'TAP version 13',
'# wrapped test failure',
'not ok 1 fail',
' ---',
' operator: fail',
' at: ($TEST/anonymous-fn.js:$LINE:$COL)',
' stack: |-',
' Error: fail',
' [... stack stripped ...]',
' at $TEST/anonymous-fn.js:$LINE:$COL',
' at Test. ($TEST/anonymous-fn/test-wrapper.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1'
].join('\n') + '\n');
};
test.createStream().pipe(concat(tc));
test('wrapped test failure', testWrapper(function (t) {
t.fail('fail');
t.end();
}));
});
tape-4.9.1/test/anonymous-fn/ 0000775 0000000 0000000 00000000000 13306334666 0016100 5 ustar 00root root 0000000 0000000 tape-4.9.1/test/anonymous-fn/test-wrapper.js 0000664 0000000 0000000 00000000426 13306334666 0021075 0 ustar 00root root 0000000 0000000 // Example of wrapper function that would invoke tape
module.exports = function (testCase) {
return function(t) {
setUp();
testCase(t);
tearDown();
};
}
function setUp() {
// ... example ...
}
function tearDown() {
// ... example ...
}
tape-4.9.1/test/array.js 0000664 0000000 0000000 00000003041 13306334666 0015121 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
tap.test('array test', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream().pipe(concat(function (rows) {
tt.same(rows.toString('utf8'), [
'TAP version 13',
'# array',
'ok 1 should be equivalent',
'ok 2 should be equivalent',
'ok 3 should be equivalent',
'ok 4 should be equivalent',
'ok 5 should be equivalent',
'',
'1..5',
'# tests 5',
'# pass 5',
'',
'# ok'
].join('\n') + '\n');
}));
test('array', function (t) {
t.plan(5);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
});
tape-4.9.1/test/bound.js 0000664 0000000 0000000 00000000302 13306334666 0015107 0 ustar 00root root 0000000 0000000 var test = require('../');
test('bind works', function (t) {
t.plan(2);
var equal = t.equal;
var deepEqual = t.deepEqual;
equal(3, 3);
deepEqual([4], [4]);
t.end();
});
tape-4.9.1/test/browser/ 0000775 0000000 0000000 00000000000 13306334666 0015132 5 ustar 00root root 0000000 0000000 tape-4.9.1/test/browser/asserts.js 0000664 0000000 0000000 00000000306 13306334666 0017153 0 ustar 00root root 0000000 0000000 var test = require('../../');
test(function (t) {
t.plan(4);
t.ok(true);
t.equal(3, 1+2);
t.deepEqual([1,2,[3,4]], [1,2,[3,4]]);
t.notDeepEqual([1,2,[3,4,5]], [1,2,[3,4]]);
});
tape-4.9.1/test/child_ordering.js 0000664 0000000 0000000 00000002564 13306334666 0016770 0 ustar 00root root 0000000 0000000 var test = require('../');
var childRan = false;
test('parent', function(t) {
t.test('child', function(t) {
childRan = true;
t.pass('child ran');
t.end();
});
t.end();
});
test('uncle', function(t) {
t.ok(childRan, 'Child should run before next top-level test');
t.end();
});
var grandParentRan = false;
var parentRan = false;
var grandChildRan = false;
test('grandparent', function(t) {
t.ok(!grandParentRan, 'grand parent ran twice');
grandParentRan = true;
t.test('parent', function(t) {
t.ok(!parentRan, 'parent ran twice');
parentRan = true;
t.test('grandchild', function(t) {
t.ok(!grandChildRan, 'grand child ran twice');
grandChildRan = true;
t.pass('grand child ran');
t.end();
});
t.pass('parent ran');
t.end();
});
t.test('other parent', function(t) {
t.ok(parentRan, 'first parent runs before second parent');
t.ok(grandChildRan, 'grandchild runs before second parent');
t.end();
});
t.pass('grandparent ran');
t.end();
});
test('second grandparent', function(t) {
t.ok(grandParentRan, 'grandparent ran');
t.ok(parentRan, 'parent ran');
t.ok(grandChildRan, 'grandchild ran');
t.pass('other grandparent ran');
t.end();
});
// vim: set softtabstop=4 shiftwidth=4:
tape-4.9.1/test/circular-things.js 0000664 0000000 0000000 00000002557 13306334666 0017114 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('circular test', function (assert) {
var test = tape.createHarness({ exit : false });
assert.plan(1);
test.createStream().pipe(concat(function (body) {
assert.equal(
stripFullStack(body.toString('utf8')),
'TAP version 13\n'
+ '# circular\n'
+ 'not ok 1 should be equal\n'
+ ' ---\n'
+ ' operator: equal\n'
+ ' expected: |-\n'
+ ' {}\n'
+ ' actual: |-\n'
+ ' { circular: [Circular] }\n'
+ ' at: Test. ($TEST/circular-things.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' Error: should be equal\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/circular-things.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ '\n'
+ '1..1\n'
+ '# tests 1\n'
+ '# pass 0\n'
+ '# fail 1\n'
);
}));
test("circular", function (t) {
t.plan(1);
var circular = {};
circular.circular = circular;
t.equal(circular, {});
})
})
tape-4.9.1/test/comment.js 0000664 0000000 0000000 00000010227 13306334666 0015451 0 ustar 00root root 0000000 0000000 var concat = require('concat-stream');
var tap = require('tap');
var tape = require('../');
// Exploratory test to ascertain proper output when no t.comment() call
// is made.
tap.test('no comment', function (assert) {
assert.plan(1);
var verify = function (output) {
assert.equal(output.toString('utf8'), [
'TAP version 13',
'# no comment',
'',
'1..0',
'# tests 0',
'# pass 0',
'',
'# ok',
''
].join('\n'));
};
var test = tape.createHarness();
test.createStream().pipe(concat(verify));
test('no comment', function (t) {
t.end();
});
});
// Exploratory test, can we call t.comment() passing nothing?
tap.test('missing argument', function (assert) {
assert.plan(1);
var test = tape.createHarness();
test.createStream();
test('missing argument', function (t) {
try {
t.comment();
t.end();
} catch (err) {
assert.equal(err.constructor, TypeError);
} finally {
assert.end();
}
});
});
// Exploratory test, can we call t.comment() passing nothing?
tap.test('null argument', function (assert) {
assert.plan(1);
var test = tape.createHarness();
test.createStream();
test('null argument', function (t) {
try {
t.comment(null);
t.end();
} catch (err) {
assert.equal(err.constructor, TypeError);
} finally {
assert.end();
}
});
});
// Exploratory test, how is whitespace treated?
tap.test('whitespace', function (assert) {
assert.plan(1);
var verify = function (output) {
assert.equal(output.toString('utf8'), [
'TAP version 13',
'# whitespace',
'# ',
'# a',
'# a',
'# a',
'',
'1..0',
'# tests 0',
'# pass 0',
'',
'# ok',
''
].join('\n'));
};
var test = tape.createHarness();
test.createStream().pipe(concat(verify));
test('whitespace', function (t) {
t.comment(' ');
t.comment(' a');
t.comment('a ');
t.comment(' a ');
t.end();
});
});
// Exploratory test, how about passing types other than strings?
tap.test('non-string types', function (assert) {
assert.plan(1);
var verify = function (output) {
assert.equal(output.toString('utf8'), [
'TAP version 13',
'# non-string types',
'# true',
'# false',
'# 42',
'# 6.66',
'# [object Object]',
'# [object Object]',
'# [object Object]',
'# function ConstructorFunction() {}',
'',
'1..0',
'# tests 0',
'# pass 0',
'',
'# ok',
''
].join('\n'));
};
var test = tape.createHarness();
test.createStream().pipe(concat(verify));
test('non-string types', function (t) {
t.comment(true);
t.comment(false);
t.comment(42);
t.comment(6.66);
t.comment({});
t.comment({"answer": 42});
function ConstructorFunction() {}
t.comment(new ConstructorFunction());
t.comment(ConstructorFunction);
t.end();
});
});
tap.test('multiline string', function (assert) {
assert.plan(1);
var verify = function (output) {
assert.equal(output.toString('utf8'), [
'TAP version 13',
'# multiline strings',
'# a',
'# b',
'# c',
'# d',
'',
'1..0',
'# tests 0',
'# pass 0',
'',
'# ok',
''
].join('\n'));
};
var test = tape.createHarness();
test.createStream().pipe(concat(verify));
test('multiline strings', function (t) {
t.comment([
'a',
'b',
].join('\n'));
t.comment([
'c',
'd',
].join('\r\n'));
t.end();
});
});
tape-4.9.1/test/common.js 0000664 0000000 0000000 00000005360 13306334666 0015301 0 ustar 00root root 0000000 0000000 var path = require('path');
var yaml = require('js-yaml');
module.exports.getDiag = function (body) {
var yamlStart = body.indexOf(' ---');
var yamlEnd = body.indexOf(' ...\n');
var diag = body.slice(yamlStart, yamlEnd).split('\n').map(function (line) {
return line.slice(2);
}).join('\n');
// The stack trace and at variable will vary depending on where the code
// is run, so just strip it out.
var withStack = yaml.safeLoad(diag);
delete withStack.stack;
delete withStack.at;
return withStack;
}
// There are three challenges associated with checking the stack traces included
// in errors:
// 1) The base checkout directory of tape might change. Because stack traces
// include absolute paths, the stack traces will change depending on the
// checkout path. We handle this by replacing the base test directory with a
// placeholder $TEST variable and the package root with a placehodler
// $TAPE variable.
// 2) Line positions within the file might change. We handle this by replacing
// line and column markers with placeholder $LINE and $COL "variables"
// a) node 0.8 does not provide nested eval line numbers, so we remove them
// 3) Stacks themselves change frequently with refactoring. We've even run into
// issues with node library refactorings "breaking" stack traces. Most of
// these changes are irrelevant to the tests themselves. To counter this, we
// strip out all stack frames that aren't directly under our test directory,
// and replace them with placeholders.
module.exports.stripFullStack = function (output) {
var stripped = ' [... stack stripped ...]';
var withDuplicates = output.split('\n').map(function (line) {
var m = line.match(/[ ]{8}at .*\((.*)\)/);
var stripChangingData = function (line) {
var withoutTestDir = line.replace(__dirname, '$TEST');
var withoutPackageDir = withoutTestDir.replace(path.dirname(__dirname), '$TAPE');
var withoutPathSep = withoutPackageDir.replace(new RegExp('\\' + path.sep, 'g'), '/');
var withoutLineNumbers = withoutPathSep.replace(/:\d+:\d+/g, ':$LINE:$COL');
var withoutNestedLineNumbers = withoutLineNumbers.replace(/, \:\$LINE:\$COL\)$/, ')');
return withoutNestedLineNumbers;
}
if (m) {
if (m[1].slice(0, __dirname.length) === __dirname) {
return stripChangingData(line);
}
return stripped;
}
return stripChangingData(line);
})
var deduped = withDuplicates.filter(function (line, ix) {
var hasPrior = line === stripped && withDuplicates[ix - 1] === stripped;
return !hasPrior;
});
return deduped.join('\n');
}
tape-4.9.1/test/deep-equal-failure.js 0000664 0000000 0000000 00000014301 13306334666 0017453 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var tapParser = require('tap-parser');
var common = require('./common');
var getDiag = common.getDiag;
var stripFullStack = common.stripFullStack;
tap.test('deep equal failure', function (assert) {
var test = tape.createHarness({ exit : false });
var stream = test.createStream();
var parser = tapParser();
assert.plan(3);
stream.pipe(parser);
stream.pipe(concat(function (body) {
assert.equal(
stripFullStack(body.toString('utf8')),
'TAP version 13\n'
+ '# deep equal\n'
+ 'not ok 1 should be equal\n'
+ ' ---\n'
+ ' operator: equal\n'
+ ' expected: |-\n'
+ ' { b: 2 }\n'
+ ' actual: |-\n'
+ ' { a: 1 }\n'
+ ' at: Test. ($TEST/deep-equal-failure.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' Error: should be equal\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/deep-equal-failure.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ '\n'
+ '1..1\n'
+ '# tests 1\n'
+ '# pass 0\n'
+ '# fail 1\n'
);
assert.deepEqual(getDiag(body), {
operator: 'equal',
expected: '{ b: 2 }',
actual: '{ a: 1 }'
});
}));
parser.once('assert', function (data) {
delete data.diag.stack;
delete data.diag.at;
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should be equal',
diag: {
operator: 'equal',
expected: '{ b: 2 }',
actual: '{ a: 1 }'
}
});
});
test("deep equal", function (t) {
t.plan(1);
t.equal({a: 1}, {b: 2});
});
})
tap.test('deep equal failure, depth 6, with option', function (assert) {
var test = tape.createHarness({ exit : false });
var stream = test.createStream();
var parser = tapParser();
assert.plan(3);
stream.pipe(parser);
stream.pipe(concat(function (body) {
assert.equal(
stripFullStack(body.toString('utf8')),
'TAP version 13\n'
+ '# deep equal\n'
+ 'not ok 1 should be equal\n'
+ ' ---\n'
+ ' operator: equal\n'
+ ' expected: |-\n'
+ ' { a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } }\n'
+ ' actual: |-\n'
+ ' { a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }\n'
+ ' at: Test. ($TEST/deep-equal-failure.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' Error: should be equal\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/deep-equal-failure.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ '\n'
+ '1..1\n'
+ '# tests 1\n'
+ '# pass 0\n'
+ '# fail 1\n'
);
assert.deepEqual(getDiag(body), {
operator: 'equal',
expected: '{ a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }'
});
}));
parser.once('assert', function (data) {
delete data.diag.stack;
delete data.diag.at;
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should be equal',
diag: {
operator: 'equal',
expected: '{ a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }'
}
});
});
test("deep equal", {objectPrintDepth: 6}, function (t) {
t.plan(1);
t.equal({ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }, { a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } });
});
})
tap.test('deep equal failure, depth 6, without option', function (assert) {
var test = tape.createHarness({ exit : false });
var stream = test.createStream();
var parser = tapParser();
assert.plan(3);
stream.pipe(parser);
stream.pipe(concat(function (body) {
assert.equal(
stripFullStack(body.toString('utf8')),
'TAP version 13\n'
+ '# deep equal\n'
+ 'not ok 1 should be equal\n'
+ ' ---\n'
+ ' operator: equal\n'
+ ' expected: |-\n'
+ ' { a: { a1: { a2: { a3: { a4: [Object] } } } } }\n'
+ ' actual: |-\n'
+ ' { a: { a1: { a2: { a3: { a4: [Object] } } } } }\n'
+ ' at: Test. ($TEST/deep-equal-failure.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' Error: should be equal\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/deep-equal-failure.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ '\n'
+ '1..1\n'
+ '# tests 1\n'
+ '# pass 0\n'
+ '# fail 1\n'
);
assert.deepEqual(getDiag(body), {
operator: 'equal',
expected: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }'
});
}));
parser.once('assert', function (data) {
delete data.diag.stack;
delete data.diag.at;
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should be equal',
diag: {
operator: 'equal',
expected: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }'
}
});
});
test("deep equal", function (t) {
t.plan(1);
t.equal({ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }, { a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } });
});
})
tape-4.9.1/test/deep.js 0000664 0000000 0000000 00000000442 13306334666 0014722 0 ustar 00root root 0000000 0000000 var test = require('../');
test('deep strict equal', function (t) {
t.notDeepEqual(
[ { a: '3' } ],
[ { a: 3 } ]
);
t.end();
});
test('deep loose equal', function (t) {
t.deepLooseEqual(
[ { a: '3' } ],
[ { a: 3 } ]
);
t.end();
});
tape-4.9.1/test/default-messages.js 0000664 0000000 0000000 00000001553 13306334666 0017242 0 ustar 00root root 0000000 0000000 var tap = require('tap');
var path = require('path');
var spawn = require('child_process').spawn;
var concat = require('concat-stream');
tap.test('default messages', function (t) {
t.plan(1);
var ps = spawn(process.execPath, [path.join(__dirname, 'messages', 'defaults.js')]);
ps.stdout.pipe(concat(function (rows) {
t.same(rows.toString('utf8'), [
'TAP version 13',
'# default messages',
'ok 1 should be truthy',
'ok 2 should be falsy',
'ok 3 should be equal',
'ok 4 should not be equal',
'ok 5 should be equivalent',
'ok 6 should be equivalent',
'ok 7 should be equivalent',
'',
'1..7',
'# tests 7',
'# pass 7',
'',
'# ok'
].join('\n') + '\n\n');
}));
});
tape-4.9.1/test/double_end.js 0000664 0000000 0000000 00000003757 13306334666 0016121 0 ustar 00root root 0000000 0000000 var test = require('tap').test;
var path = require('path');
var concat = require('concat-stream');
var spawn = require('child_process').spawn;
var stripFullStack = require('./common').stripFullStack;
test(function (t) {
t.plan(2);
var ps = spawn(process.execPath, [path.join(__dirname, 'double_end', 'double.js')]);
ps.on('exit', function (code) {
t.equal(code, 1);
});
ps.stdout.pipe(concat(function (body) {
// The implementation of node's timer library has changed over time. We
// need to reverse engineer the error we expect to see.
// This code is unfortunately by necessity highly coupled to node
// versions, and may require tweaking with future versions of the timers
// library.
function doEnd() { throw new Error() };
var to = setTimeout(doEnd, 5000);
clearTimeout(to);
to._onTimeout = doEnd;
var stackExpected;
var atExpected;
try {
to._onTimeout();
}
catch (e) {
stackExpected = stripFullStack(e.stack).split('\n')[1];
stackExpected = stackExpected.replace('double_end.js', 'double_end/double.js');
stackExpected = stackExpected.trim();
atExpected = stackExpected.replace(/^at\s+/, 'at: ');
}
var stripped = stripFullStack(body.toString('utf8'));
t.equal(stripped, [
'TAP version 13',
'# double end',
'ok 1 should be equal',
'not ok 2 .end() called twice',
' ---',
' operator: fail',
' ' + atExpected,
' stack: |-',
' Error: .end() called twice',
' [... stack stripped ...]',
' ' + stackExpected,
' [... stack stripped ...]',
' ...',
'',
'1..2',
'# tests 2',
'# pass 1',
'# fail 1',
].join('\n') + '\n\n');
}));
});
tape-4.9.1/test/double_end/ 0000775 0000000 0000000 00000000000 13306334666 0015547 5 ustar 00root root 0000000 0000000 tape-4.9.1/test/double_end/double.js 0000664 0000000 0000000 00000000262 13306334666 0017357 0 ustar 00root root 0000000 0000000 var test = require('../../');
test('double end', function (t) {
function doEnd() {
t.end();
}
t.equal(1 + 1, 2);
t.end();
setTimeout(doEnd, 5);
});
tape-4.9.1/test/end-as-callback.js 0000664 0000000 0000000 00000004546 13306334666 0016717 0 ustar 00root root 0000000 0000000 var tap = require("tap");
var forEach = require("for-each");
var tape = require("../");
var concat = require('concat-stream');
tap.test("tape assert.end as callback", function (tt) {
var test = tape.createHarness({ exit: false })
test.createStream().pipe(concat(function (rows) {
tt.equal(rows.toString('utf8'), [
'TAP version 13',
'# do a task and write',
'ok 1 null',
'ok 2 should be equal',
'# do a task and write fail',
'ok 3 null',
'ok 4 should be equal',
'not ok 5 Error: fail',
getStackTrace(rows), // tap error stack
'',
'1..5',
'# tests 5',
'# pass 4',
'# fail 1'
].join('\n') + '\n');
tt.end()
}));
test("do a task and write", function (assert) {
fakeAsyncTask("foo", function (err, value) {
assert.ifError(err)
assert.equal(value, "taskfoo")
fakeAsyncWrite("bar", assert.end)
})
})
test("do a task and write fail", function (assert) {
fakeAsyncTask("bar", function (err, value) {
assert.ifError(err)
assert.equal(value, "taskbar")
fakeAsyncWriteFail("baz", assert.end)
})
})
})
function fakeAsyncTask(name, cb) {
cb(null, "task" + name)
}
function fakeAsyncWrite(name, cb) {
cb(null)
}
function fakeAsyncWriteFail(name, cb) {
cb(new Error("fail"))
}
/**
* extract the stack trace for the failed test.
* this will change dependent on the environment
* so no point hard-coding it in the test assertion
* see: https://git.io/v6hGG for example
* @param String rows - the tap output lines
* @returns String stacktrace - just the error stack part
*/
function getStackTrace(rows) {
var stacktrace = ' ---\n';
var extract = false;
forEach(rows.toString('utf8').split('\n'), function (row) {
if (!extract) {
if (row.indexOf('---') > -1) { // start of stack trace
extract = true;
}
} else {
if (row.indexOf('...') > -1) { // end of stack trace
extract = false;
stacktrace += ' ...';
} else {
stacktrace += row + '\n';
}
}
});
// console.log(stacktrace);
return stacktrace;
}
tape-4.9.1/test/exit.js 0000664 0000000 0000000 00000011153 13306334666 0014757 0 ustar 00root root 0000000 0000000 var tap = require('tap');
var path = require('path');
var spawn = require('child_process').spawn;
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('exit ok', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(rows.toString('utf8'), [
'TAP version 13',
'# array',
'# hi',
'ok 1 should be equivalent',
'ok 2 should be equivalent',
'ok 3 should be equivalent',
'ok 4 should be equivalent',
'ok 5 should be equivalent',
'',
'1..5',
'# tests 5',
'# pass 5',
'',
'# ok',
'', // yes, these double-blank-lines at the end are required.
'' // if you can figure out how to remove them, please do!
].join('\n'));
}
var ps = spawn(process.execPath, [path.join(__dirname, 'exit', 'ok.js')]);
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.equal(code, 0);
});
});
tap.test('exit fail', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# array',
'ok 1 should be equivalent',
'ok 2 should be equivalent',
'ok 3 should be equivalent',
'ok 4 should be equivalent',
'not ok 5 should be equivalent',
' ---',
' operator: deepEqual',
' expected: [ [ 1, 2, [ 3, 4444 ] ], [ 5, 6 ] ]',
' actual: [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]',
' at: ($TEST/exit/fail.js:$LINE:$COL)',
' stack: |-',
' Error: should be equivalent',
' [... stack stripped ...]',
' at $TEST/exit/fail.js:$LINE:$COL',
' at eval (eval at ($TEST/exit/fail.js:$LINE:$COL))',
' at eval (eval at ($TEST/exit/fail.js:$LINE:$COL))',
' at Test. ($TEST/exit/fail.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..5',
'# tests 5',
'# pass 4',
'# fail 1'
].join('\n') + '\n\n');
};
var ps = spawn(process.execPath, [path.join(__dirname, 'exit', 'fail.js')]);
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.notEqual(code, 0);
});
});
tap.test('too few exit', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# array',
'ok 1 should be equivalent',
'ok 2 should be equivalent',
'ok 3 should be equivalent',
'ok 4 should be equivalent',
'ok 5 should be equivalent',
'not ok 6 plan != count',
' ---',
' operator: fail',
' expected: 6',
' actual: 5',
' at: process. ($TAPE/index.js:$LINE:$COL)',
' stack: |-',
' Error: plan != count',
' [... stack stripped ...]',
' ...',
'',
'1..6',
'# tests 6',
'# pass 5',
'# fail 1'
].join('\n') + '\n\n');
};
var ps = spawn(process.execPath, [path.join(__dirname, '/exit/too_few.js')]);
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.notEqual(code, 0);
});
});
tap.test('more planned in a second test', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# first',
'ok 1 should be truthy',
'# second',
'ok 2 should be truthy',
'not ok 3 plan != count',
' ---',
' operator: fail',
' expected: 2',
' actual: 1',
' at: process. ($TAPE/index.js:$LINE:$COL)',
' stack: |-',
' Error: plan != count',
' [... stack stripped ...]',
' ...',
'',
'1..3',
'# tests 3',
'# pass 2',
'# fail 1'
].join('\n') + '\n\n');
};
var ps = spawn(process.execPath, [path.join(__dirname, '/exit/second.js')]);
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.notEqual(code, 0);
});
});
tape-4.9.1/test/exit/ 0000775 0000000 0000000 00000000000 13306334666 0014420 5 ustar 00root root 0000000 0000000 tape-4.9.1/test/exit/fail.js 0000664 0000000 0000000 00000001422 13306334666 0015670 0 ustar 00root root 0000000 0000000 var test = require('../../');
var falafel = require('falafel');
test('array', function (t) {
t.plan(5);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4444 ] ], [ 5, 6 ] ]);
}
);
});
tape-4.9.1/test/exit/ok.js 0000664 0000000 0000000 00000001444 13306334666 0015372 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../../');
test('array', function (t) {
t.comment('hi');
t.plan(5);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
tape-4.9.1/test/exit/second.js 0000664 0000000 0000000 00000000241 13306334666 0016226 0 ustar 00root root 0000000 0000000 var test = require('../../');
test('first', function (t) {
t.plan(1);
t.ok(true);
});
test('second', function (t) {
t.plan(2);
t.ok(true);
});
tape-4.9.1/test/exit/too_few.js 0000664 0000000 0000000 00000001417 13306334666 0016423 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var test = require('../../');
test('array', function (t) {
t.plan(6);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
tape-4.9.1/test/exposed-harness.js 0000664 0000000 0000000 00000000430 13306334666 0017112 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
tap.test('main harness object is exposed', function (assert) {
assert.equal(typeof tape.getHarness, 'function', 'tape.getHarness is a function')
assert.equal(tape.getHarness()._results.pass, 0)
assert.end()
})
tape-4.9.1/test/fail.js 0000664 0000000 0000000 00000004562 13306334666 0014727 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('array test', function (tt) {
tt.plan(1);
var test = tape.createHarness({ exit : false });
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# array',
'ok 1 should be equivalent',
'ok 2 should be equivalent',
'ok 3 should be equivalent',
'ok 4 should be equivalent',
'not ok 5 should be equivalent',
' ---',
' operator: deepEqual',
' expected: [ [ 1, 2, [ 3, 4444 ] ], [ 5, 6 ] ]',
' actual: [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]',
' at: ($TEST/fail.js:$LINE:$COL)',
' stack: |-',
' Error: should be equivalent',
' [... stack stripped ...]',
' at $TEST/fail.js:$LINE:$COL',
' at eval (eval at ($TEST/fail.js:$LINE:$COL))',
' at eval (eval at ($TEST/fail.js:$LINE:$COL))',
' at Test. ($TEST/fail.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..5',
'# tests 5',
'# pass 4',
'# fail 1',
''
].join('\n'));
};
test.createStream().pipe(concat(tc));
test('array', function (t) {
t.plan(5);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4444 ] ], [ 5, 6 ] ]);
}
);
});
});
tape-4.9.1/test/has spaces.js 0000664 0000000 0000000 00000002163 13306334666 0016021 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('array test', function (tt) {
tt.plan(1);
var test = tape.createHarness({ exit : false });
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# fail',
'not ok 1 this should fail',
' ---',
' operator: fail',
' at: Test. ($TEST/has spaces.js:$LINE:$COL)',
' stack: |-',
' Error: this should fail',
' [... stack stripped ...]',
' at Test. ($TEST/has spaces.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
].join('\n'));
};
test.createStream().pipe(concat(tc));
test('fail', function (t) {
t.fail('this should fail');
t.end();
});
});
tape-4.9.1/test/many.js 0000664 0000000 0000000 00000000277 13306334666 0014757 0 ustar 00root root 0000000 0000000 var test = require('../');
test('many tests', function (t) {
t.plan(100);
for (var i = 0; i < 100; i++) {
setTimeout(function () { t.pass() }, Math.random() * 50);
}
});
tape-4.9.1/test/max_listeners.js 0000664 0000000 0000000 00000000440 13306334666 0016660 0 ustar 00root root 0000000 0000000 var spawn = require('child_process').spawn;
var path = require('path');
var ps = spawn(process.execPath, [path.join(__dirname, 'max_listeners', 'source.js')]);
ps.stdout.pipe(process.stdout, { end : false });
ps.stderr.on('data', function (buf) {
console.log('not ok ' + buf);
});
tape-4.9.1/test/max_listeners/ 0000775 0000000 0000000 00000000000 13306334666 0016324 5 ustar 00root root 0000000 0000000 tape-4.9.1/test/max_listeners/source.js 0000664 0000000 0000000 00000000203 13306334666 0020155 0 ustar 00root root 0000000 0000000 var test = require('../../');
for (var i = 0; i < 11; i ++) {
test(function (t) { t.ok(true, 'true is truthy'); t.end() });
}
tape-4.9.1/test/messages/ 0000775 0000000 0000000 00000000000 13306334666 0015256 5 ustar 00root root 0000000 0000000 tape-4.9.1/test/messages/defaults.js 0000664 0000000 0000000 00000000431 13306334666 0017421 0 ustar 00root root 0000000 0000000 var test = require('../../');
test('default messages', function (t) {
t.plan(7);
t.ok(true);
t.notOk(false);
t.equal(true, true);
t.notEqual(true, false);
t.deepEqual(true, true);
t.deepLooseEqual(true, true);
t.notDeepLooseEqual(true, false);
});
tape-4.9.1/test/nested-async-plan-noend.js 0000664 0000000 0000000 00000001577 13306334666 0020445 0 ustar 00root root 0000000 0000000 var test = require('../');
test('Harness async test support', function(t) {
t.plan(3);
t.ok(true, 'sync child A');
t.test('sync child B', function(tt) {
tt.plan(2);
setTimeout(function(){
tt.test('async grandchild A', function(ttt) {
ttt.plan(1);
ttt.ok(true);
});
}, 50);
setTimeout(function() {
tt.test('async grandchild B', function(ttt) {
ttt.plan(1);
ttt.ok(true);
});
}, 100);
});
setTimeout(function() {
t.test('async child', function(tt) {
tt.plan(2);
tt.ok(true, 'sync grandchild in async child A');
tt.test('sync grandchild in async child B', function(ttt) {
ttt.plan(1);
ttt.ok(true);
});
});
}, 200);
});
tape-4.9.1/test/nested-sync-noplan-noend.js 0000664 0000000 0000000 00000002065 13306334666 0020632 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
tap.test('nested sync test without plan or end', function (tt) {
tt.plan(1);
var test = tape.createHarness();
var tc = function (rows) {
tt.same(rows.toString('utf8'), [
'TAP version 13',
'# nested without plan or end',
'# first',
'ok 1 should be truthy',
'# second',
'ok 2 should be truthy',
'',
'1..2',
'# tests 2',
'# pass 2',
'',
'# ok'
].join('\n') + '\n');
};
test.createStream().pipe(concat(tc));
test('nested without plan or end', function(t) {
t.test('first', function(q) {
setTimeout(function first() {
q.ok(true);
q.end()
}, 10);
});
t.test('second', function(q) {
setTimeout(function second() {
q.ok(true);
q.end()
}, 10);
});
});
});
tape-4.9.1/test/nested.js 0000664 0000000 0000000 00000004067 13306334666 0015276 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
tap.test('array test', function (tt) {
tt.plan(1);
var test = tape.createHarness();
var tc = function (rows) {
tt.same(rows.toString('utf8'), [
'TAP version 13',
'# nested array test',
'ok 1 should be equivalent',
'ok 2 should be equivalent',
'ok 3 should be equivalent',
'ok 4 should be equivalent',
'ok 5 should be equivalent',
'# inside test',
'ok 6 should be truthy',
'ok 7 should be truthy',
'# another',
'ok 8 should be truthy',
'',
'1..8',
'# tests 8',
'# pass 8',
'',
'# ok'
].join('\n') + '\n');
};
test.createStream().pipe(concat(tc));
test('nested array test', function (t) {
t.plan(6);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
t.test('inside test', function (q) {
q.plan(2);
q.ok(true);
setTimeout(function () {
q.ok(true);
}, 100);
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
test('another', function (t) {
t.plan(1);
setTimeout(function () {
t.ok(true);
}, 50);
});
});
tape-4.9.1/test/nested2.js 0000664 0000000 0000000 00000000462 13306334666 0015353 0 ustar 00root root 0000000 0000000 var test = require('../');
test(function(t) {
var i = 0
t.test('setup', function(t) {
process.nextTick(function() {
t.equal(i, 0, 'called once')
i++
t.end()
})
})
t.test('teardown', function(t) {
t.end()
})
t.end()
})
tape-4.9.1/test/no_callback.js 0000664 0000000 0000000 00000000062 13306334666 0016233 0 ustar 00root root 0000000 0000000 var test = require('../');
test('No callback.');
tape-4.9.1/test/onFailure.js 0000664 0000000 0000000 00000001024 13306334666 0015726 0 ustar 00root root 0000000 0000000 var tap = require("tap");
var tape = require("../").createHarness();
//Because this test passing depends on a failure,
//we must direct the failing output of the inner test
var noop = function(){}
var mockSink = {on:noop, removeListener:noop, emit:noop, end:noop}
tape.createStream().pipe(mockSink);
tap.test("on failure", { timeout: 1000 }, function(tt) {
tt.plan(1);
tape("dummy test", function(t) {
t.fail();
t.end();
});
tape.onFailure(function() {
tt.pass("tape ended");
});
});
tape-4.9.1/test/onFinish.js 0000664 0000000 0000000 00000000405 13306334666 0015561 0 ustar 00root root 0000000 0000000 var tap = require("tap");
var tape = require("../");
tap.test("on finish", {timeout: 1000}, function (tt) {
tt.plan(1);
tape.onFinish(function() {
tt.pass('tape ended');
});
tape('dummy test', function(t) {
t.end();
});
});
tape-4.9.1/test/only-twice.js 0000664 0000000 0000000 00000000701 13306334666 0016075 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
tap.test('only twice error', function (assert) {
var test = tape.createHarness({ exit : false });
test.only("first only", function (t) {
t.end()
});
assert.throws(function() {
test.only('second only', function(t) {
t.end();
});
}, {
name: 'Error',
message: 'there can only be one only test'
});
assert.end();
});
tape-4.9.1/test/only.js 0000664 0000000 0000000 00000001734 13306334666 0014773 0 ustar 00root root 0000000 0000000 var tap = require('tap');
var tape = require('../');
var concat = require('concat-stream');
tap.test('tape only test', function (tt) {
var test = tape.createHarness({ exit: false });
var ran = [];
var tc = function (rows) {
tt.deepEqual(rows.toString('utf8'), [
'TAP version 13',
'# run success',
'ok 1 assert name',
'',
'1..1',
'# tests 1',
'# pass 1',
'',
'# ok'
].join('\n') + '\n');
tt.deepEqual(ran, [ 3 ]);
tt.end()
};
test.createStream().pipe(concat(tc));
test("never run fail", function (t) {
ran.push(1);
t.equal(true, false)
t.end()
})
test("never run success", function (t) {
ran.push(2);
t.equal(true, true)
t.end()
})
test.only("run success", function (t) {
ran.push(3);
t.ok(true, "assert name")
t.end()
})
})
tape-4.9.1/test/only2.js 0000664 0000000 0000000 00000000214 13306334666 0015045 0 ustar 00root root 0000000 0000000 var test = require('../');
test('only2 test 1', function (t) {
t.end();
});
test.only('only2 test 2', function (t) {
t.end();
});
tape-4.9.1/test/only3.js 0000664 0000000 0000000 00000000354 13306334666 0015053 0 ustar 00root root 0000000 0000000 var test = require('../');
test('only3 test 1', function (t) {
t.fail('not 1');
t.end();
});
test.only('only3 test 2', function (t) {
t.end();
});
test('only3 test 3', function (t) {
t.fail('not 3');
t.end();
});
tape-4.9.1/test/only4.js 0000664 0000000 0000000 00000000273 13306334666 0015054 0 ustar 00root root 0000000 0000000 var test = require('../');
test('only4 duplicate test name', function (t) {
t.fail('not 1');
t.end();
});
test.only('only4 duplicate test name', function (t) {
t.end();
});
tape-4.9.1/test/only5.js 0000664 0000000 0000000 00000000273 13306334666 0015055 0 ustar 00root root 0000000 0000000 var test = require('../');
test.only('only5 duplicate test name', function (t) {
t.end();
});
test('only5 duplicate test name', function (t) {
t.fail('not 2');
t.end();
});
tape-4.9.1/test/order.js 0000664 0000000 0000000 00000000435 13306334666 0015122 0 ustar 00root root 0000000 0000000 var test = require('../');
var current = 0;
test(function (t) {
t.equal(current++, 0);
t.end();
});
test(function (t) {
t.plan(1);
setTimeout(function () {
t.equal(current++, 1);
}, 100);
});
test(function (t) {
t.equal(current++, 2);
t.end();
});
tape-4.9.1/test/plan_optional.js 0000664 0000000 0000000 00000000433 13306334666 0016644 0 ustar 00root root 0000000 0000000 var test = require('../');
test('plan should be optional', function (t) {
t.pass('no plan here');
t.end();
});
test('no plan async', function (t) {
setTimeout(function() {
t.pass('ok');
t.end();
}, 100);
});
// vim: set softtabstop=4 shiftwidth=4:
tape-4.9.1/test/require.js 0000664 0000000 0000000 00000003550 13306334666 0015464 0 ustar 00root root 0000000 0000000 var tap = require('tap');
var spawn = require('child_process').spawn;
var concat = require('concat-stream');
tap.test('requiring a single module', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(rows.toString('utf8'), [
'TAP version 13',
'# module-a',
'ok 1 loaded module a',
'# test-a',
'ok 2 module-a loaded in same context',
'ok 3 test ran after module-a was loaded',
'',
'1..3',
'# tests 3',
'# pass 3',
'',
'# ok'
].join('\n') + '\n\n');
};
var ps = tape('-r ./require/a require/test-a.js');
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.equal(code, 0);
});
});
tap.test('requiring multiple modules', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(rows.toString('utf8'), [
'TAP version 13',
'# module-a',
'ok 1 loaded module a',
'# module-b',
'ok 2 loaded module b',
'# test-a',
'ok 3 module-a loaded in same context',
'ok 4 test ran after module-a was loaded',
'# test-b',
'ok 5 module-b loaded in same context',
'ok 6 test ran after module-b was loaded',
'',
'1..6',
'# tests 6',
'# pass 6',
'',
'# ok'
].join('\n') + '\n\n');
};
var ps = tape('-r ./require/a -r ./require/b require/test-a.js require/test-b.js');
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.equal(code, 0);
});
});
function tape(args) {
var proc = require('child_process')
var bin = __dirname + '/../bin/tape'
return proc.spawn('node', [bin].concat(args.split(' ')), { cwd: __dirname })
}
tape-4.9.1/test/require/ 0000775 0000000 0000000 00000000000 13306334666 0015123 5 ustar 00root root 0000000 0000000 tape-4.9.1/test/require/a.js 0000664 0000000 0000000 00000000211 13306334666 0015673 0 ustar 00root root 0000000 0000000 var tape = require('../..');
tape.test('module-a', function(t) {
t.plan(1)
t.pass('loaded module a')
})
global.module_a = true
tape-4.9.1/test/require/b.js 0000664 0000000 0000000 00000000211 13306334666 0015674 0 ustar 00root root 0000000 0000000 var tape = require('../..');
tape.test('module-b', function(t) {
t.plan(1)
t.pass('loaded module b')
})
global.module_b = true
tape-4.9.1/test/require/test-a.js 0000664 0000000 0000000 00000000275 13306334666 0016662 0 ustar 00root root 0000000 0000000 var tape = require('../..');
tape.test('test-a', function(t) {
t.ok(global.module_a, 'module-a loaded in same context')
t.pass('test ran after module-a was loaded')
t.end()
})
tape-4.9.1/test/require/test-b.js 0000664 0000000 0000000 00000000275 13306334666 0016663 0 ustar 00root root 0000000 0000000 var tape = require('../..');
tape.test('test-b', function(t) {
t.ok(global.module_b, 'module-b loaded in same context')
t.pass('test ran after module-b was loaded')
t.end()
})
tape-4.9.1/test/skip.js 0000664 0000000 0000000 00000002141 13306334666 0014751 0 ustar 00root root 0000000 0000000 var test = require('../');
var ran = 0;
var concat = require('concat-stream');
var tap = require('tap');
tap.test('test SKIP comment', function (assert) {
assert.plan(1);
var verify = function (output) {
assert.equal(output.toString('utf8'), [
'TAP version 13',
'# SKIP skipped',
'',
'1..0',
'# tests 0',
'# pass 0',
'',
'# ok',
''
].join('\n'));
};
var tapeTest = test.createHarness();
tapeTest.createStream().pipe(concat(verify));
tapeTest('skipped', { skip: true }, function (t) {
t.end();
});
});
test('skip this', { skip: true }, function(t) {
t.fail('this should not even run');
ran++;
t.end();
});
test.skip('skip this too', function(t) {
t.fail('this should not even run');
ran++;
t.end();
});
test('skip subtest', function(t) {
ran++;
t.test('skip this', { skip: true }, function(t) {
t.fail('this should not even run');
t.end();
});
t.end();
});
// vim: set softtabstop=4 shiftwidth=4:
tape-4.9.1/test/stackTrace.js 0000664 0000000 0000000 00000015660 13306334666 0016101 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var tapParser = require('tap-parser');
var yaml = require('js-yaml');
tap.test('preserves stack trace with newlines', function (tt) {
tt.plan(3);
var test = tape.createHarness();
var stream = test.createStream();
var parser = stream.pipe(tapParser());
var stackTrace = 'foo\n bar';
parser.once('assert', function (data) {
delete data.diag.at;
tt.deepEqual(data, {
ok: false,
id: 1,
name: "Error: Preserve stack",
diag: {
stack: stackTrace,
operator: 'error',
expected: 'undefined',
actual: '[Error: Preserve stack]'
}
});
});
stream.pipe(concat(function (body) {
var body = body.toString('utf8');
body = stripAt(body);
tt.equal(
body,
'TAP version 13\n'
+ '# multiline stack trace\n'
+ 'not ok 1 Error: Preserve stack\n'
+ ' ---\n'
+ ' operator: error\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ ' [Error: Preserve stack]\n'
+ ' stack: |-\n'
+ ' foo\n'
+ ' bar\n'
+ ' ...\n'
+ '\n'
+ '1..1\n'
+ '# tests 1\n'
+ '# pass 0\n'
+ '# fail 1\n'
);
tt.deepEqual(getDiag(body), {
stack: stackTrace,
operator: 'error',
expected: 'undefined',
actual: '[Error: Preserve stack]'
});
}));
test('multiline stack trace', function (t) {
t.plan(1);
var err = new Error('Preserve stack');
err.stack = stackTrace;
t.error(err);
});
});
tap.test('parses function name from original stack', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream();
test._results._watch = function (t) {
t.on('result', function (res) {
tt.equal('Test.testFunctionNameParsing', res.functionName)
});
};
test('t.equal stack trace', function testFunctionNameParsing(t) {
t.equal(true, false, 'true should be false');
t.end();
});
});
tap.test('parses function name from original stack for anonymous function', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream();
test._results._watch = function (t) {
t.on('result', function (res) {
tt.equal('Test.', res.functionName)
});
};
test('t.equal stack trace', function (t) {
t.equal(true, false, 'true should be false');
t.end();
});
});
tap.test('preserves stack trace for failed assertions', function (tt) {
tt.plan(6);
var test = tape.createHarness();
var stream = test.createStream();
var parser = stream.pipe(tapParser());
var stack = ''
parser.once('assert', function (data) {
tt.equal(typeof data.diag.at, 'string');
tt.equal(typeof data.diag.stack, 'string');
at = data.diag.at || '';
stack = data.diag.stack || '';
tt.ok(/^Error: true should be false(\n at .+)+/.exec(stack), 'stack should be a stack')
tt.deepEqual(data, {
ok: false,
id: 1,
name: "true should be false",
diag: {
at: at,
stack: stack,
operator: 'equal',
expected: false,
actual: true
}
});
});
stream.pipe(concat(function (body) {
var body = body.toString('utf8');
body = stripAt(body);
tt.equal(
body,
'TAP version 13\n'
+ '# t.equal stack trace\n'
+ 'not ok 1 true should be false\n'
+ ' ---\n'
+ ' operator: equal\n'
+ ' expected: false\n'
+ ' actual: true\n'
+ ' stack: |-\n'
+ ' '
+ stack.replace(/\n/g, '\n ') + '\n'
+ ' ...\n'
+ '\n'
+ '1..1\n'
+ '# tests 1\n'
+ '# pass 0\n'
+ '# fail 1\n'
);
tt.deepEqual(getDiag(body), {
stack: stack,
operator: 'equal',
expected: false,
actual: true
});
}));
test('t.equal stack trace', function (t) {
t.plan(1);
t.equal(true, false, 'true should be false');
});
});
tap.test('preserves stack trace for failed assertions where actual===falsy', function (tt) {
tt.plan(6);
var test = tape.createHarness();
var stream = test.createStream();
var parser = stream.pipe(tapParser());
var stack = ''
parser.once('assert', function (data) {
tt.equal(typeof data.diag.at, 'string');
tt.equal(typeof data.diag.stack, 'string');
at = data.diag.at || '';
stack = data.diag.stack || '';
tt.ok(/^Error: false should be true(\n at .+)+/.exec(stack), 'stack should be a stack')
tt.deepEqual(data, {
ok: false,
id: 1,
name: "false should be true",
diag: {
at: at,
stack: stack,
operator: 'equal',
expected: true,
actual: false
}
});
});
stream.pipe(concat(function (body) {
var body = body.toString('utf8');
body = stripAt(body);
tt.equal(
body,
'TAP version 13\n'
+ '# t.equal stack trace\n'
+ 'not ok 1 false should be true\n'
+ ' ---\n'
+ ' operator: equal\n'
+ ' expected: true\n'
+ ' actual: false\n'
+ ' stack: |-\n'
+ ' '
+ stack.replace(/\n/g, '\n ') + '\n'
+ ' ...\n'
+ '\n'
+ '1..1\n'
+ '# tests 1\n'
+ '# pass 0\n'
+ '# fail 1\n'
);
tt.deepEqual(getDiag(body), {
stack: stack,
operator: 'equal',
expected: true,
actual: false
});
}));
test('t.equal stack trace', function (t) {
t.plan(1);
t.equal(false, true, 'false should be true');
});
});
function getDiag (body) {
var yamlStart = body.indexOf(' ---');
var yamlEnd = body.indexOf(' ...\n');
var diag = body.slice(yamlStart, yamlEnd).split('\n').map(function (line) {
return line.slice(2);
}).join('\n');
// Get rid of 'at' variable (which has a line number / path of its own that's
// difficult to check).
var withStack = yaml.safeLoad(diag);
delete withStack.at;
return withStack;
}
function stripAt (body) {
return body.replace(/^\s*at:\s+Test.*$\n/m, '');
}
tape-4.9.1/test/subcount.js 0000664 0000000 0000000 00000000422 13306334666 0015645 0 ustar 00root root 0000000 0000000 var test = require('../');
test('parent test', function (t) {
t.plan(2);
t.test('first child', function (t) {
t.plan(1);
t.pass('pass first child');
})
t.test(function (t) {
t.plan(1);
t.pass('pass second child');
})
})
tape-4.9.1/test/subtest_and_async.js 0000664 0000000 0000000 00000001110 13306334666 0017506 0 ustar 00root root 0000000 0000000 var test = require('../');
var asyncFunction = function (callback) {
setTimeout(callback, Math.random * 50);
};
test('master test', function (t) {
t.test('subtest 1', function (t) {
t.pass('subtest 1 before async call');
asyncFunction(function () {
t.pass('subtest 1 in async callback');
t.end();
})
});
t.test('subtest 2', function (t) {
t.pass('subtest 2 before async call');
asyncFunction(function () {
t.pass('subtest 2 in async callback');
t.end();
})
});
});
tape-4.9.1/test/subtest_plan.js 0000664 0000000 0000000 00000000670 13306334666 0016513 0 ustar 00root root 0000000 0000000 var test = require('../');
test('parent', function (t) {
t.plan(3)
var firstChildRan = false;
t.pass('assertion in parent');
t.test('first child', function (t) {
t.plan(1);
t.pass('pass first child');
firstChildRan = true;
});
t.test('second child', function (t) {
t.plan(2);
t.ok(firstChildRan, 'first child ran first');
t.pass('pass second child');
});
});
tape-4.9.1/test/throws.js 0000664 0000000 0000000 00000020321 13306334666 0015331 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
function fn() {
throw new TypeError('RegExp');
}
function getNonFunctionMessage(fn) {
try {
fn();
} catch (e) {
return e.message;
}
}
var getter = function () { return 'message'; };
var messageGetterError = Object.defineProperty(
{ custom: 'error' },
'message',
{ configurable: true, enumerable: true, get: getter }
);
var thrower = function () { throw messageGetterError; };
tap.test('failures', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream().pipe(concat(function (body) {
tt.equal(
stripFullStack(body.toString('utf8')),
'TAP version 13\n'
+ '# non functions\n'
+ 'not ok 1 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ " { [TypeError: " + getNonFunctionMessage() + "] message: '" + getNonFunctionMessage() + "' }\n"
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' TypeError: ' + getNonFunctionMessage(undefined) + '\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ 'not ok 2 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ " { [TypeError: " + getNonFunctionMessage(null) + "] message: '" + getNonFunctionMessage(null) + "' }\n"
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' TypeError: ' + getNonFunctionMessage(null) + '\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ 'not ok 3 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ " { [TypeError: " + getNonFunctionMessage(true) + "] message: '" + getNonFunctionMessage(true) + "' }\n"
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' TypeError: ' + getNonFunctionMessage(true) + '\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ 'not ok 4 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ " { [TypeError: " + getNonFunctionMessage(false) + "] message: '" + getNonFunctionMessage(false) + "' }\n"
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' TypeError: ' + getNonFunctionMessage(false) + '\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ 'not ok 5 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ " { [TypeError: " + getNonFunctionMessage('abc') + "] message: '" + getNonFunctionMessage('abc') + "' }\n"
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' TypeError: ' + getNonFunctionMessage('abc') + '\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ 'not ok 6 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ " { [TypeError: " + getNonFunctionMessage(/a/g) + "] message: '" + getNonFunctionMessage(/a/g) + "' }\n"
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' TypeError: ' + getNonFunctionMessage(/a/g) + '\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ 'not ok 7 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ " { [TypeError: " + getNonFunctionMessage([]) + "] message: '" + getNonFunctionMessage([]) + "' }\n"
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' TypeError: ' + getNonFunctionMessage([]) + '\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ 'not ok 8 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: |-\n'
+ ' undefined\n'
+ ' actual: |-\n'
+ " { [TypeError: " + getNonFunctionMessage({}) + "] message: '" + getNonFunctionMessage({}) + "' }\n"
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' TypeError: ' + getNonFunctionMessage({}) + '\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ '# function\n'
+ 'not ok 9 should throw\n'
+ ' ---\n'
+ ' operator: throws\n'
+ ' expected: undefined\n'
+ ' actual: undefined\n'
+ ' at: Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' Error: should throw\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/throws.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ '# custom error messages\n'
+ 'ok 10 "message" is enumerable\n'
+ "ok 11 { custom: 'error', message: 'message' }\n"
+ 'ok 12 getter is still the same\n'
+ '# throws null\n'
+ 'ok 13 throws null\n'
+ '\n1..13\n'
+ '# tests 13\n'
+ '# pass 4\n'
+ '# fail 9\n'
);
}));
test('non functions', function (t) {
t.plan(8);
t.throws();
t.throws(null);
t.throws(true);
t.throws(false);
t.throws('abc');
t.throws(/a/g);
t.throws([]);
t.throws({});
});
test('function', function (t) {
t.plan(1);
t.throws(function () {});
});
test('custom error messages', function (t) {
t.plan(3);
t.equal(Object.prototype.propertyIsEnumerable.call(messageGetterError, 'message'), true, '"message" is enumerable');
t.throws(thrower, "{ custom: 'error', message: 'message' }");
t.equal(Object.getOwnPropertyDescriptor(messageGetterError, 'message').get, getter, 'getter is still the same');
});
test('throws null', function (t) {
t.plan(1);
t.throws(function () { throw null; }, 'throws null');
t.end();
});
});
tape-4.9.1/test/timeout.js 0000664 0000000 0000000 00000000417 13306334666 0015475 0 ustar 00root root 0000000 0000000 var test = require('../');
var ran = 0;
test('timeout', function(t) {
t.pass('this should run');
ran++;
setTimeout(function () {
t.end();
}, 100);
});
test('should still run', { timeout: 50 }, function(t) {
t.equal(ran, 1);
t.end();
});
tape-4.9.1/test/timeoutAfter.js 0000664 0000000 0000000 00000001661 13306334666 0016461 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('timeoutAfter test', function (tt) {
tt.plan(1);
var test = tape.createHarness();
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# timeoutAfter',
'not ok 1 test timed out after 1ms',
' ---',
' operator: fail',
' stack: |-',
' Error: test timed out after 1ms',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1'
].join('\n') + '\n');
};
test.createStream().pipe(concat(tc));
test('timeoutAfter', function (t) {
t.plan(1);
t.timeoutAfter(1);
});
});
tape-4.9.1/test/too_many.js 0000664 0000000 0000000 00000004517 13306334666 0015641 0 ustar 00root root 0000000 0000000 var falafel = require('falafel');
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('array test', function (tt) {
tt.plan(1);
var test = tape.createHarness({ exit : false });
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# array',
'ok 1 should be equivalent',
'ok 2 should be equivalent',
'ok 3 should be equivalent',
'ok 4 should be equivalent',
'not ok 5 plan != count',
' ---',
' operator: fail',
' expected: 3',
' actual: 4',
' at: ($TEST/too_many.js:$LINE:$COL)',
' stack: |-',
' Error: plan != count',
' [... stack stripped ...]',
' at $TEST/too_many.js:$LINE:$COL',
' at eval (eval at ($TEST/too_many.js:$LINE:$COL))',
' at eval (eval at ($TEST/too_many.js:$LINE:$COL))',
' at Test. ($TEST/too_many.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 6 should be equivalent',
'',
'1..6',
'# tests 6',
'# pass 5',
'# fail 1'
].join('\n') + '\n');
};
test.createStream().pipe(concat(tc));
test('array', function (t) {
t.plan(3);
var src = '(' + function () {
var xs = [ 1, 2, [ 3, 4 ] ];
var ys = [ 5, 6 ];
g([ xs, ys ]);
} + ')()';
var output = falafel(src, function (node) {
if (node.type === 'ArrayExpression') {
node.update('fn(' + node.source() + ')');
}
});
var arrays = [
[ 3, 4 ],
[ 1, 2, [ 3, 4 ] ],
[ 5, 6 ],
[ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
];
Function(['fn','g'], output)(
function (xs) {
t.same(arrays.shift(), xs);
return xs;
},
function (xs) {
t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
}
);
});
});
tape-4.9.1/test/undef.js 0000664 0000000 0000000 00000002417 13306334666 0015112 0 ustar 00root root 0000000 0000000 var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('array test', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream().pipe(concat(function (body) {
tt.equal(
stripFullStack(body.toString('utf8')),
'TAP version 13\n'
+ '# undef\n'
+ 'not ok 1 should be equivalent\n'
+ ' ---\n'
+ ' operator: deepEqual\n'
+ ' expected: |-\n'
+ ' { beep: undefined }\n'
+ ' actual: |-\n'
+ ' {}\n'
+ ' at: Test. ($TEST/undef.js:$LINE:$COL)\n'
+ ' stack: |-\n'
+ ' Error: should be equivalent\n'
+ ' [... stack stripped ...]\n'
+ ' at Test. ($TEST/undef.js:$LINE:$COL)\n'
+ ' [... stack stripped ...]\n'
+ ' ...\n'
+ '\n'
+ '1..1\n'
+ '# tests 1\n'
+ '# pass 0\n'
+ '# fail 1\n'
);
}));
test('undef', function (t) {
t.plan(1);
t.deepEqual({}, { beep: undefined });
});
});