pax_global_header 0000666 0000000 0000000 00000000064 14202055663 0014515 g ustar 00root root 0000000 0000000 52 comment=e6f091a78fd5e611c616fabff6a4e10c2af3ac4c
tape-5.5.2/ 0000775 0000000 0000000 00000000000 14202055663 0012457 5 ustar 00root root 0000000 0000000 tape-5.5.2/.editorconfig 0000664 0000000 0000000 00000001037 14202055663 0015135 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 = 180
block_comment_start = /*
block_comment = *
block_comment_end = */
[.nycrc]
indent_style = tab
[*.md]
indent_style = space
indent_size = 4
[*.yml]
indent_style = space
indent_size = 2
[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 = 1
tape-5.5.2/.eslintrc 0000664 0000000 0000000 00000006622 14202055663 0014311 0 ustar 00root root 0000000 0000000 {
"root": true,
"extends": "@ljharb",
"env": {
"browser": true,
"node": true,
},
"parserOptions": {
"ecmaVersion": 5,
"allowReserved": false,
},
"rules": {
"array-bracket-spacing": "off",
"complexity": "off",
"func-style": "warn",
"indent": ["error", 4],
"no-magic-numbers": "off",
"max-lines": "warn",
"max-lines-per-function": "warn",
"max-statements-per-line": [2, { "max": 2 }],
"max-statements": "warn",
"multiline-comment-style": "off",
"no-negated-condition": "off",
"no-underscore-dangle": "warn",
"no-use-before-define": "warn",
"object-curly-newline": "off",
"sort-keys": "warn",
},
"ignorePatterns": ["syntax-error.*"],
"overrides": [
{
"files": ["*.mjs", "test/import/package_type/*.js"],
"extends": "@ljharb/eslint-config/esm",
},
{
"files": ["bin/**"],
"rules": {
"global-require": "off",
"no-process-exit": "off",
"quote-props": ["error", "as-needed", {
"keywords": false,
}],
},
},
{
"files": ["bin/import-or-require.js"],
"parserOptions": {
"ecmaVersion": 2020,
},
},
{
"files": ["index.js"],
"rules": {
"no-param-reassign": "warn",
},
},
{
"files": ["lib/results.js"],
"rules": {
"no-cond-assign": "warn",
"no-param-reassign": "warn",
"no-plusplus": "warn",
},
},
{
"files": ["lib/test.js"],
"rules": {
"eqeqeq": "warn",
"func-name-matching": "off",
"max-params": "off",
"no-continue": "off",
"no-invalid-this": "off",
"no-multi-assign": "off",
"no-param-reassign": "warn",
"no-plusplus": "warn",
"no-restricted-syntax": "off",
"operator-linebreak": ["error", "before"],
},
},
{
"files": ["test/async-await/*"],
"parserOptions": {
"ecmaVersion": 2017,
},
},
{
"files": ["example/**", "test/**"],
"globals": {
"g": false,
},
"rules": {
"no-new-func": "off",
},
},
{
"files": ["example/**"],
"rules": {
"array-bracket-newline": "off",
"global-require": "off",
"no-console": "off",
},
},
{
"files": ["test/**"],
"rules": {
"dot-notation": [2, {
"allowKeywords": true,
"allowPattern": "throws"
}],
"id-length": "off",
"max-len": "off",
"max-lines-per-function": "off",
"no-plusplus": "off",
"no-throw-literal": "off",
},
},
{
"files": ["test/*/**"],
"rules": {
"camelcase": "off",
},
},
],
}
tape-5.5.2/.github/ 0000775 0000000 0000000 00000000000 14202055663 0014017 5 ustar 00root root 0000000 0000000 tape-5.5.2/.github/workflows/ 0000775 0000000 0000000 00000000000 14202055663 0016054 5 ustar 00root root 0000000 0000000 tape-5.5.2/.github/workflows/node-aught.yml 0000664 0000000 0000000 00000000516 14202055663 0020634 0 ustar 00root root 0000000 0000000 name: 'Tests: node.js < 10'
on: [pull_request, push]
jobs:
tests:
uses: ljharb/actions/.github/workflows/node.yml@main
with:
range: '< 10'
type: minors
command: npm run tests-only
node:
name: 'node < 10'
needs: [tests]
runs-on: ubuntu-latest
steps:
- run: 'echo tests completed'
tape-5.5.2/.github/workflows/node-pretest.yml 0000664 0000000 0000000 00000000206 14202055663 0021206 0 ustar 00root root 0000000 0000000 name: 'Tests: pretest/posttest'
on: [pull_request, push]
jobs:
tests:
uses: ljharb/actions/.github/workflows/pretest.yml@main
tape-5.5.2/.github/workflows/node-tens.yml 0000664 0000000 0000000 00000000521 14202055663 0020471 0 ustar 00root root 0000000 0000000 name: 'Tests: node.js >= 10'
on: [pull_request, push]
jobs:
tests:
uses: ljharb/actions/.github/workflows/node.yml@main
with:
range: '>= 10'
type: minors
command: npm run tests-only
node:
name: 'node >= 10'
needs: [tests]
runs-on: ubuntu-latest
steps:
- run: 'echo tests completed'
tape-5.5.2/.github/workflows/rebase.yml 0000664 0000000 0000000 00000000411 14202055663 0020034 0 ustar 00root root 0000000 0000000 name: Automatic Rebase
on: [pull_request_target]
jobs:
_:
name: "Automatic Rebase"
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: ljharb/rebase@master
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
tape-5.5.2/.github/workflows/require-allow-edits.yml 0000664 0000000 0000000 00000000303 14202055663 0022471 0 ustar 00root root 0000000 0000000 name: Require “Allow Edits”
on: [pull_request_target]
jobs:
_:
name: "Require “Allow Edits”"
runs-on: ubuntu-latest
steps:
- uses: ljharb/require-allow-edits@main
tape-5.5.2/.gitignore 0000664 0000000 0000000 00000000202 14202055663 0014441 0 ustar 00root root 0000000 0000000 # gitignore
/node_modules
# Only apps should have lockfiles
yarn.lock
package-lock.json
# coverage data
coverage/
.nyc_output/
tape-5.5.2/.npmignore 0000664 0000000 0000000 00000000225 14202055663 0014455 0 ustar 00root root 0000000 0000000 # gitignore
/node_modules
# Only apps should have lockfiles
yarn.lock
package-lock.json
# coverage data
coverage/
.nyc_output/
.github/workflows
tape-5.5.2/.npmrc 0000664 0000000 0000000 00000000023 14202055663 0013572 0 ustar 00root root 0000000 0000000 package-lock=false
tape-5.5.2/.nycrc 0000664 0000000 0000000 00000000266 14202055663 0013602 0 ustar 00root root 0000000 0000000 {
"all": true,
"check-coverage": false,
"reporter": ["text-summary", "text", "html", "json"],
"exclude": [
"bin/import-or-require.js",
"coverage",
"example",
"test"
]
}
tape-5.5.2/LICENSE 0000664 0000000 0000000 00000002057 14202055663 0013470 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2012 James Halliday
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-5.5.2/bin/ 0000775 0000000 0000000 00000000000 14202055663 0013227 5 ustar 00root root 0000000 0000000 tape-5.5.2/bin/import-or-require.js 0000664 0000000 0000000 00000000710 14202055663 0017165 0 ustar 00root root 0000000 0000000 'use strict';
const { extname: extnamePath } = require('path');
const { pathToFileURL } = require('url');
const getPackageType = require('get-package-type');
// eslint-disable-next-line consistent-return
module.exports = function importOrRequire(file) {
const ext = extnamePath(file);
if (ext === '.mjs' || (ext === '.js' && getPackageType.sync(file) === 'module')) {
return import(pathToFileURL(file).href);
}
require(file);
};
tape-5.5.2/bin/tape 0000775 0000000 0000000 00000005357 14202055663 0014120 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
'use strict';
var parseOpts = require('minimist');
var objectKeys = require('object-keys');
var opts = parseOpts(process.argv.slice(2), {
alias: { r: 'require', i: 'ignore' },
string: ['require', 'ignore'],
boolean: ['only'],
default: { r: [], i: null, only: null }
});
if (typeof opts.only === 'boolean') {
process.env.NODE_TAPE_NO_ONLY_TEST = !opts.only;
}
var cwd = process.cwd();
if (typeof opts.require === 'string') {
opts.require = [opts.require];
}
var resolveModule;
opts.require.forEach(function (module) {
var options = { basedir: cwd, extensions: objectKeys(require.extensions) };
if (module) {
if (!resolveModule) { resolveModule = require('resolve').sync; }
// This check ensures we ignore `-r ""`, trailing `-r`, or other silly things the user might (inadvertently) be doing.
require(resolveModule(module, options));
}
});
var resolvePath = require('path').resolve;
var matcher;
if (typeof opts.ignore === 'string') {
var readFileSync = require('fs').readFileSync;
try {
var ignoreStr = readFileSync(resolvePath(cwd, opts.ignore || '.gitignore'), 'utf-8');
} catch (e) {
console.error(e.message);
process.exit(2);
}
var ignore = require('dotignore');
matcher = ignore.createMatcher(ignoreStr);
}
var glob = require('glob');
var files = opts._.reduce(function (result, 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 globFiles = glob.sync(arg);
if (!Array.isArray(globFiles)) {
throw new TypeError('unknown error: glob.sync("' + arg + '") did not return an array or throw. Please report this.');
}
return result.concat(globFiles);
}, []).filter(function (file) {
return !matcher || !matcher.shouldIgnore(file);
}).map(function (file) {
return resolvePath(cwd, file);
});
var hasImport = require('has-dynamic-import');
hasImport().then(function (hasSupport) {
// the nextTick callback gets called outside the promise chain, avoiding
// promises and unhandled rejections when only loading commonjs files
process.nextTick(importFiles, hasSupport);
});
var tape = require('../');
function importFiles(hasSupport) {
if (!hasSupport) {
return files.forEach(function (x) { require(x); });
}
var importOrRequire = require('./import-or-require');
tape.wait();
var filesPromise = files.reduce(function (promise, file) {
return promise ? promise.then(function () {
return importOrRequire(file);
}) : importOrRequire(file);
}, null);
return filesPromise ? filesPromise.then(function () { tape.run(); }) : tape.run();
}
// vim: ft=javascript
tape-5.5.2/example/ 0000775 0000000 0000000 00000000000 14202055663 0014112 5 ustar 00root root 0000000 0000000 tape-5.5.2/example/array.js 0000664 0000000 0000000 00000001414 14202055663 0015566 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/example/fail.js 0000664 0000000 0000000 00000001436 14202055663 0015367 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/example/nested.js 0000664 0000000 0000000 00000002076 14202055663 0015737 0 ustar 00root root 0000000 0000000 'use strict';
var falafel = require('falafel');
var test = require('../');
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, '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-5.5.2/example/nested_fail.js 0000664 0000000 0000000 00000002100 14202055663 0016716 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/example/no_callback.js 0000664 0000000 0000000 00000000077 14202055663 0016704 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
test('No cb test');
tape-5.5.2/example/not_enough_fail.js 0000664 0000000 0000000 00000001373 14202055663 0017614 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/example/static/ 0000775 0000000 0000000 00000000000 14202055663 0015401 5 ustar 00root root 0000000 0000000 tape-5.5.2/example/static/build.sh 0000775 0000000 0000000 00000000061 14202055663 0017034 0 ustar 00root root 0000000 0000000 #!/bin/bash
browserify ../timing.js -o bundle.js
tape-5.5.2/example/static/index.html 0000664 0000000 0000000 00000000542 14202055663 0017377 0 ustar 00root root 0000000 0000000
tape-5.5.2/example/static/server.js 0000664 0000000 0000000 00000000231 14202055663 0017241 0 ustar 00root root 0000000 0000000 'use strict';
var http = require('http');
var ecstatic = require('ecstatic')(__dirname);
var server = http.createServer(ecstatic);
server.listen(8000);
tape-5.5.2/example/stream/ 0000775 0000000 0000000 00000000000 14202055663 0015405 5 ustar 00root root 0000000 0000000 tape-5.5.2/example/stream/object.js 0000664 0000000 0000000 00000000416 14202055663 0017212 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/example/stream/tap.js 0000664 0000000 0000000 00000000312 14202055663 0016523 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
var path = require('path');
test.createStream().pipe(process.stdout);
process.argv.slice(2).forEach(function (file) {
require(path.resolve(file));
});
tape-5.5.2/example/stream/test/ 0000775 0000000 0000000 00000000000 14202055663 0016364 5 ustar 00root root 0000000 0000000 tape-5.5.2/example/stream/test/x_fail.js 0000664 0000000 0000000 00000000164 14202055663 0020165 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../../');
test(function (t) {
t.plan(1);
t.equal('beep', 'boop');
});
tape-5.5.2/example/stream/test/y.js 0000664 0000000 0000000 00000000275 14202055663 0017176 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/example/throw_fail.js 0000664 0000000 0000000 00000000247 14202055663 0016611 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
test('throw', function (t) {
t.plan(2);
setTimeout(function () {
throw new Error('doom');
}, 100);
});
tape-5.5.2/example/timing.js 0000664 0000000 0000000 00000000373 14202055663 0015742 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
test('timing test', function (t) {
t.plan(2);
t.equal(typeof Date.now, 'function');
var start = Date.now();
setTimeout(function () {
t.ok(Date.now() - start > 100);
}, 100);
});
tape-5.5.2/example/too_many_fail.js 0000664 0000000 0000000 00000001375 14202055663 0017276 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/example/two.js 0000664 0000000 0000000 00000000531 14202055663 0015260 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/index.js 0000664 0000000 0000000 00000011445 14202055663 0014131 0 ustar 00root root 0000000 0000000 'use strict';
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';
module.exports = (function () {
var wait = false;
var harness;
var lazyLoad = function () {
// eslint-disable-next-line no-invalid-this
return getHarness().apply(this, arguments);
};
lazyLoad.wait = function () {
wait = true;
};
lazyLoad.run = function () {
var run = getHarness().run;
if (run) { run(); }
};
lazyLoad.only = function () {
return getHarness().only.apply(this, arguments);
};
lazyLoad.createStream = function (opts) {
var options = opts || {};
if (!harness) {
var output = through();
getHarness({ stream: output, objectMode: options.objectMode });
return output;
}
return harness.createStream(options);
};
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, wait); }
return harness;
}
}());
function createExitHarness(conf, wait) {
var config = conf || {};
var harness = createHarness({
autoclose: defined(config.autoclose, false),
noOnly: defined(conf.noOnly, defined(process.env.NODE_TAPE_NO_ONLY_TEST, false))
});
var running = false;
var ended = false;
if (wait) {
harness.run = run;
} else {
run();
}
if (config.exit === false) { return harness; }
if (!canEmitExit || !canExit) { return harness; }
process.on('exit', function (code) {
// let the process exit cleanly.
if (typeof code === 'number' && 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) {
t._exit();
}
}
}
harness.close();
process.removeAllListeners('exit'); // necessary for node v0.6
process.exit(code || harness._exitCode); // eslint-disable-line no-process-exit
});
return harness;
function run() {
if (running) { return; }
running = true;
var stream = harness.createStream({ objectMode: config.objectMode });
var es = stream.pipe(config.stream || createDefaultStream());
if (canEmitExit) {
// TODO: use `err` arg?
// eslint-disable-next-line no-unused-vars
es.on('error', function (err) { harness._exitCode = 1; });
}
stream.on('end', function () { ended = true; });
}
}
module.exports.createHarness = createHarness;
module.exports.Test = Test;
module.exports.test = module.exports; // tap compat
module.exports.test.skip = Test.skip;
function createHarness(conf_) {
var results = createResult();
if (!conf_ || 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.todo && !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'); }
if (conf_.noOnly) { throw new Error('`only` tests are prohibited'); }
only = true;
var t = test.apply(null, arguments);
results.only(t);
return t;
};
test._exitCode = 0;
test.close = function () { results.close(); };
return test;
}
tape-5.5.2/lib/ 0000775 0000000 0000000 00000000000 14202055663 0013225 5 ustar 00root root 0000000 0000000 tape-5.5.2/lib/default_stream.js 0000664 0000000 0000000 00000001710 14202055663 0016561 0 ustar 00root root 0000000 0000000 'use strict';
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); // eslint-disable-line no-console
} catch (e) {
stream.emit('error', e);
}
}
line = '';
}
};
tape-5.5.2/lib/results.js 0000664 0000000 0000000 00000015021 14202055663 0015263 0 ustar 00root root 0000000 0000000 'use strict';
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 callBound = require('call-bind/callBound');
var has = require('has');
var regexpTest = callBound('RegExp.prototype.test');
var $split = callBound('String.prototype.split');
var $replace = callBound('String.prototype.replace');
var $shift = callBound('Array.prototype.shift');
var $push = callBound('Array.prototype.push');
var yamlIndicators = /:|-|\?/;
var nextTick = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick;
module.exports = Results;
inherits(Results, EventEmitter);
function coalesceWhiteSpaces(str) {
return $replace(String(str), /\s+/g, ' ');
}
function Results() {
if (!(this instanceof Results)) { return new Results(); }
this.count = 0;
this.fail = 0;
this.pass = 0;
this.todo = 0;
this._stream = through();
this.tests = [];
this._only = null;
this._isRunning = false;
}
Results.prototype.createStream = function (opts) {
if (!opts) { opts = {}; }
var self = this;
var output;
var 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,
skip: t._skip,
todo: t._todo
};
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) {
if (res && typeof res === 'object') {
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);
}
if (!this._isRunning) {
this._isRunning = true;
nextTick(function next() {
var t;
while (t = getNextTest(self)) {
t.run();
if (!t.ended) {
t.once('end', function () { nextTick(next); });
return;
}
}
self.emit('done');
});
}
return output;
};
Results.prototype.push = function (t) {
var self = this;
$push(self.tests, 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 () {
var premsg = '';
if (t._skip) {
premsg = 'SKIP ';
} else if (t._todo) {
premsg = 'TODO ';
}
write('# ' + premsg + coalesceWhiteSpaces(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 || res.todo) {
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 + self.todo) + '\n');
if (self.todo) { write('# todo ' + self.todo + '\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 ? ' ' + coalesceWhiteSpaces(res.name) : '';
if (res.skip) {
output += ' # SKIP' + (typeof res.skip === 'string' ? ' ' + coalesceWhiteSpaces(res.skip) : '');
} else if (res.todo) {
output += ' # TODO' + (typeof res.todo === 'string' ? ' ' + coalesceWhiteSpaces(res.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 = $split(String(stack), '\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 $shift(results.tests);
}
do {
var t = $shift(results.tests);
if (t && results._only === t) {
return t;
}
} while (results.tests.length !== 0);
return void undefined;
}
function invalidYaml(str) {
return regexpTest(yamlIndicators, str);
}
tape-5.5.2/lib/test.js 0000664 0000000 0000000 00000055144 14202055663 0014553 0 ustar 00root root 0000000 0000000 'use strict';
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 isRegExp = require('is-regex');
var trim = require('string.prototype.trim');
var callBound = require('call-bind/callBound');
var forEach = require('for-each');
var inspect = require('object-inspect');
var is = require('object-is');
var objectKeys = require('object-keys');
var every = require('array.prototype.every');
var isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
var toLowerCase = callBound('String.prototype.toLowerCase');
var isProto = callBound('Object.prototype.isPrototypeOf');
var $test = callBound('RegExp.prototype.test');
var objectToString = callBound('Object.prototype.toString');
var $split = callBound('String.prototype.split');
var $replace = callBound('String.prototype.replace');
var $strSlice = callBound('String.prototype.slice');
var $push = callBound('Array.prototype.push');
var $shift = callBound('Array.prototype.shift');
module.exports = Test;
var nextTick = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick;
var safeSetTimeout = setTimeout;
var safeClearTimeout = clearTimeout;
inherits(Test, EventEmitter);
// eslint-disable-next-line no-unused-vars
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._todo = args.opts.todo || false;
this._timeout = args.opts.timeout;
this._plan = undefined;
this._cb = args.cb;
this._progeny = [];
this._teardown = [];
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 run() {
this.emit('prerun');
if (!this._cb || this._skip) {
this._end();
return;
}
if (this._timeout != null) {
this.timeoutAfter(this._timeout);
}
var callbackReturn = this._cb(this);
if (
typeof Promise === 'function'
&& callbackReturn
&& typeof callbackReturn.then === 'function'
) {
var self = this;
Promise.resolve(callbackReturn).then(function onResolve() {
if (!self.calledEnd) {
self.end();
}
})['catch'](function onError(err) {
if (err instanceof Error || objectToString(err) === '[object Error]') {
self.ifError(err);
} else {
self.fail(err);
}
self.end();
});
return;
}
this.emit('run');
};
Test.prototype.test = function test(name, opts, cb) {
var self = this;
var t = new Test(name, opts, cb);
$push(this._progeny, 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 comment(msg) {
var that = this;
forEach($split(trim(msg), '\n'), function (aMsg) {
that.emit('result', $replace(trim(aMsg), /^#\s*/, ''));
});
};
Test.prototype.plan = function plan(n) {
this._plan = n;
this.emit('plan', n);
};
Test.prototype.timeoutAfter = function timeoutAfter(ms) {
if (!ms) { throw new Error('timeoutAfter requires a timespan'); }
var self = this;
var timeout = safeSetTimeout(function () {
self.fail(self.name + ' timed out after ' + ms + 'ms');
self.end();
}, ms);
this.once('end', function () {
safeClearTimeout(timeout);
});
};
Test.prototype.end = function end(err) {
if (arguments.length >= 1 && !!err) {
this.ifError(err);
}
if (this.calledEnd) {
this.fail('.end() already called');
}
this.calledEnd = true;
this._end();
};
Test.prototype.teardown = function teardown(fn) {
if (typeof fn !== 'function') {
this.fail('teardown: ' + inspect(fn) + ' is not a function');
} else {
this._teardown.push(fn);
}
};
Test.prototype._end = function _end(err) {
var self = this;
if (!this._cb && !this._todo && !this._skip) {
this.fail('# TODO ' + this.name);
}
if (this._progeny.length) {
var t = $shift(this._progeny);
t.on('end', function () { self._end(); });
t.run();
return;
}
function next() {
if (self._teardown.length === 0) {
completeEnd();
return;
}
var fn = self._teardown.shift();
var res;
try {
res = fn();
} catch (e) {
self.fail(e);
}
if (res && typeof res.then === 'function') {
res.then(next, function (_err) {
// TODO: wth?
err = err || _err;
});
} else {
next();
}
}
next();
function completeEnd() {
if (!self.ended) { self.emit('end'); }
var pendingAsserts = self._pendingAsserts();
if (!self._planError && self._plan !== undefined && pendingAsserts) {
self._planError = true;
self.fail('plan != count', {
expected: self._plan,
actual: self.assertCount
});
}
self.ended = true;
}
};
Test.prototype._exit = function _exit() {
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: ' + this.name, {
exiting: true
});
}
};
Test.prototype._pendingAsserts = function _pendingAsserts() {
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 || {};
ok = !!ok || !!extra.skip;
var name = defined(extra.message, opts.message, '(unnamed assert)');
if (this.calledEnd && opts.operator !== 'fail') {
this.fail('.end() already called: ' + name);
return;
}
var res = {
id: self.assertCount++,
ok: ok,
skip: defined(extra.skip, opts.skip),
todo: defined(extra.todo, opts.todo, self._todo),
name: name,
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 = !!(this._ok && ok);
if (!ok && !res.todo) {
res.error = defined(extra.error, opts.error, new Error(res.name));
}
if (!ok) {
var e = new Error('exception');
var err = $split(e.stack || '', '\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 correctly extract a function name (if any) and path / line
number 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-zA-Z]:\\)[^:\)]+:(\d+)(?::(\d+))?)\)?/
*/
var re = /^(?:[^\s]*\s*\bat\s+)(?:(.*)\s+\()?((?:\/|[a-zA-Z]:\\)[^:)]+:(\d+)(?::(\d+))?)\)?$/;
var lineWithTokens = $replace($replace(err[i], process.cwd(), '/$CWD'), __dirname, '/$TEST');
var m = re.exec(lineWithTokens);
if (!m) {
continue;
}
var callDescription = m[1] || '';
var filePath = $replace($replace(m[2], '/$CWD', process.cwd()), '/$TEST', __dirname);
if ($strSlice(filePath, 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 = $split(callDescription, /\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 fail(msg, extra) {
this._assert(false, {
message: msg,
operator: 'fail',
extra: extra
});
};
Test.prototype.pass = function pass(msg, extra) {
this._assert(true, {
message: msg,
operator: 'pass',
extra: extra
});
};
Test.prototype.skip = function skip(msg, extra) {
this._assert(true, {
message: msg,
operator: 'skip',
skip: true,
extra: extra
});
};
var testAssert = 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
= testAssert;
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',
error: err,
extra: extra
});
}
Test.prototype.error
= Test.prototype.ifError
= Test.prototype.ifErr
= Test.prototype.iferror
= error;
function strictEqual(a, b, msg, extra) {
if (arguments.length < 2) {
throw new TypeError('two arguments must be provided to compare');
}
this._assert(is(a, b), {
message: defined(msg, 'should be strictly equal'),
operator: 'equal',
actual: a,
expected: b,
extra: extra
});
}
Test.prototype.equal
= Test.prototype.equals
= Test.prototype.isEqual
= Test.prototype.strictEqual
= Test.prototype.strictEquals
= Test.prototype.is
= strictEqual;
function notStrictEqual(a, b, msg, extra) {
if (arguments.length < 2) {
throw new TypeError('two arguments must be provided to compare');
}
this._assert(!is(a, b), {
message: defined(msg, 'should not be strictly equal'),
operator: 'notEqual',
actual: a,
expected: b,
extra: extra
});
}
Test.prototype.notEqual
= Test.prototype.notEquals
= Test.prototype.isNotEqual
= Test.prototype.doesNotEqual
= Test.prototype.isInequal
= Test.prototype.notStrictEqual
= Test.prototype.notStrictEquals
= Test.prototype.isNot
= Test.prototype.not
= notStrictEqual;
function looseEqual(a, b, msg, extra) {
if (arguments.length < 2) {
throw new TypeError('two arguments must be provided to compare');
}
this._assert(a == b, {
message: defined(msg, 'should be loosely equal'),
operator: 'looseEqual',
actual: a,
expected: b,
extra: extra
});
}
Test.prototype.looseEqual
= Test.prototype.looseEquals
= looseEqual;
function notLooseEqual(a, b, msg, extra) {
if (arguments.length < 2) {
throw new TypeError('two arguments must be provided to compare');
}
this._assert(a != b, {
message: defined(msg, 'should not be loosely equal'),
operator: 'notLooseEqual',
actual: a,
expected: b,
extra: extra
});
}
Test.prototype.notLooseEqual
= Test.prototype.notLooseEquals
= notLooseEqual;
function tapeDeepEqual(a, b, msg, extra) {
if (arguments.length < 2) {
throw new TypeError('two arguments must be provided to compare');
}
this._assert(deepEqual(a, b, { strict: true }), {
message: defined(msg, 'should be deeply equivalent'),
operator: 'deepEqual',
actual: a,
expected: b,
extra: extra
});
}
Test.prototype.deepEqual
= Test.prototype.deepEquals
= Test.prototype.isEquivalent
= Test.prototype.same
= tapeDeepEqual;
function notDeepEqual(a, b, msg, extra) {
if (arguments.length < 2) {
throw new TypeError('two arguments must be provided to compare');
}
this._assert(!deepEqual(a, b, { strict: true }), {
message: defined(msg, 'should not be deeply equivalent'),
operator: 'notDeepEqual',
actual: a,
expected: b,
extra: extra
});
}
Test.prototype.notDeepEqual
= Test.prototype.notDeepEquals
= Test.prototype.notEquivalent
= Test.prototype.notDeeply
= Test.prototype.notSame
= Test.prototype.isNotDeepEqual
= Test.prototype.isNotDeeply
= Test.prototype.isNotEquivalent
= Test.prototype.isInequivalent
= notDeepEqual;
function deepLooseEqual(a, b, msg, extra) {
if (arguments.length < 2) {
throw new TypeError('two arguments must be provided to compare');
}
this._assert(deepEqual(a, b), {
message: defined(msg, 'should be loosely deeply equivalent'),
operator: 'deepLooseEqual',
actual: a,
expected: b,
extra: extra
});
}
Test.prototype.deepLooseEqual
= deepLooseEqual;
function notDeepLooseEqual(a, b, msg, extra) {
if (arguments.length < 2) {
throw new TypeError('two arguments must be provided to compare');
}
this._assert(!deepEqual(a, b), {
message: defined(msg, 'should not be loosely deeply equivalent'),
operator: 'notDeepLooseEqual',
actual: a,
expected: b,
extra: extra
});
}
Test.prototype.notDeepLooseEqual
= notDeepLooseEqual;
Test.prototype['throws'] = function (fn, expected, msg, extra) {
if (typeof expected === 'string') {
msg = expected;
expected = undefined;
}
var caught;
try {
fn();
} catch (err) {
caught = { error: err };
if (Object(err) === err && (!isEnumerable(err, 'message') || !has(err, 'message'))) {
var message = err.message;
delete err.message;
err.message = message;
}
}
var passed = caught;
if (caught) {
if (typeof expected === 'string' && caught.error && caught.error.message === expected) {
throw new TypeError('The "error/message" argument is ambiguous. The error message ' + inspect(expected) + ' is identical to the message.');
}
if (typeof expected === 'function') {
if (typeof expected.prototype !== 'undefined' && caught.error instanceof expected) {
passed = true;
} else if (isProto(Error, expected)) {
passed = false;
} else {
passed = expected.call({}, caught.error) === true;
}
} else if (isRegExp(expected)) {
passed = $test(expected, caught.error);
expected = inspect(expected);
} else if (expected && typeof expected === 'object') { // Handle validation objects.
var keys = objectKeys(expected);
// Special handle errors to make sure the name and the message are compared as well.
if (expected instanceof Error) {
$push(keys, 'name', 'message');
} else if (keys.length === 0) {
throw new TypeError('`throws` validation object must not be empty');
}
passed = every(keys, function (key) {
if (typeof caught.error[key] === 'string' && isRegExp(expected[key]) && $test(expected[key], caught.error[key])) {
return true;
}
if (key in caught.error && deepEqual(caught.error[key], expected[key], { strict: true })) {
return true;
}
return false;
});
}
}
this._assert(!!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 doesNotThrow(fn, expected, msg, extra) {
if (typeof expected === 'string') {
msg = expected;
expected = undefined;
}
var caught;
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.prototype.match = function match(string, regexp, msg, extra) {
if (!isRegExp(regexp)) {
this._assert(false, {
message: defined(msg, 'The "regexp" argument must be an instance of RegExp. Received type ' + typeof regexp + ' (' + inspect(regexp) + ')'),
operator: 'match',
actual: objectToString(regexp),
expected: '[object RegExp]',
extra: extra
});
} else if (typeof string !== 'string') {
this._assert(false, {
message: defined(msg, 'The "string" argument must be of type string. Received type ' + typeof string + ' (' + inspect(string) + ')'),
operator: 'match',
actual: string === null ? null : typeof string,
expected: 'string',
extra: extra
});
} else {
var matches = $test(regexp, string);
var message = defined(
msg,
'The input ' + (matches ? 'matched' : 'did not match') + ' the regular expression ' + inspect(regexp) + '. Input: ' + inspect(string)
);
this._assert(matches, {
message: message,
operator: 'match',
actual: string,
expected: regexp,
extra: extra
});
}
};
Test.prototype.doesNotMatch = function doesNotMatch(string, regexp, msg, extra) {
if (!isRegExp(regexp)) {
this._assert(false, {
message: defined(msg, 'The "regexp" argument must be an instance of RegExp. Received type ' + typeof regexp + ' (' + inspect(regexp) + ')'),
operator: 'doesNotMatch',
actual: objectToString(regexp),
expected: '[object RegExp]',
extra: extra
});
} else if (typeof string !== 'string') {
this._assert(false, {
message: defined(msg, 'The "string" argument must be of type string. Received type ' + typeof string + ' (' + inspect(string) + ')'),
operator: 'doesNotMatch',
actual: string === null ? null : typeof string,
expected: 'string',
extra: extra
});
} else {
var matches = $test(regexp, string);
var message = defined(
msg,
'The input ' + (matches ? 'was expected to not match' : 'did not match') + ' the regular expression ' + inspect(regexp) + '. Input: ' + inspect(string)
);
this._assert(!matches, {
message: message,
operator: 'doesNotMatch',
actual: string,
expected: regexp,
extra: extra
});
}
};
// eslint-disable-next-line no-unused-vars
Test.skip = function skip(name_, _opts, _cb) {
var args = getTestArgs.apply(null, arguments);
args.opts.skip = true;
return new Test(args.name, args.opts, args.cb);
};
// vim: set softtabstop=4 shiftwidth=4:
tape-5.5.2/package.json 0000664 0000000 0000000 00000006153 14202055663 0014752 0 ustar 00root root 0000000 0000000 {
"name": "tape",
"version": "5.5.2",
"description": "tap-producing test harness for node and browsers",
"main": "index.js",
"browser": {
"fs": false
},
"exports": {
".": [
{
"default": "./index.js"
},
"./index.js"
],
"./lib/default_stream": "./lib/default_stream.js",
"./lib/results": "./lib/results.js",
"./lib/test": "./lib/test.js",
"./package": "./package.json",
"./package.json": "./package.json"
},
"bin": "./bin/tape",
"directories": {
"example": "example",
"test": "test"
},
"dependencies": {
"array.prototype.every": "^1.1.3",
"call-bind": "^1.0.2",
"deep-equal": "^2.0.5",
"defined": "^1.0.0",
"dotignore": "^0.1.2",
"for-each": "^0.3.3",
"get-package-type": "^0.1.0",
"glob": "^7.2.0",
"has": "^1.0.3",
"has-dynamic-import": "^2.0.1",
"inherits": "^2.0.4",
"is-regex": "^1.1.4",
"minimist": "^1.2.5",
"object-inspect": "^1.12.0",
"object-is": "^1.1.5",
"object-keys": "^1.1.1",
"object.assign": "^4.1.2",
"resolve": "^2.0.0-next.3",
"resumer": "^0.0.0",
"string.prototype.trim": "^1.2.5",
"through": "^2.3.8"
},
"devDependencies": {
"@ljharb/eslint-config": "^20.2.2",
"array.prototype.flatmap": "^1.2.5",
"aud": "^2.0.0",
"concat-stream": "^1.6.2",
"eclint": "^2.8.1",
"ecstatic": "^4.1.4",
"es-value-fixtures": "^1.2.1",
"eslint": "=8.8.0",
"falafel": "^2.2.4",
"js-yaml": "^3.14.0",
"safe-publish-latest": "^2.0.0",
"tap": "^8.0.1",
"tap-parser": "^3.0.5"
},
"scripts": {
"prepublishOnly": "safe-publish-latest",
"prepublish": "!(type not-in-publish) || not-in-publish || npm run prepublishOnly",
"prelint": "eclint check $(git ls-files 2>/dev/null | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git' || echo '*.md *.js test/*.js')",
"lint": "eslint --ext .js,.cjs,.mjs . bin/*",
"pretest": "npm run lint",
"test": "npm run tests-only",
"posttest": "aud --production",
"tests-only": "nyc tap test/*.js",
"test:example": "find example -name '*.js' | grep -v fail | grep -v static | xargs tap"
},
"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-5.5.2/readme.markdown 0000664 0000000 0000000 00000052536 14202055663 0015473 0 ustar 00root root 0000000 0000000 # tape [![Version Badge][npm-version-svg][package-url]]
tap-producing test harness for node and browsers
[![github actions][actions-image]][actions-url]
[![coverage][codecov-image]][codecov-url]
[![dependency status][deps-svg]][deps-url]
[![dev dependency status][dev-deps-svg]][dev-deps-url]
[![License][license-image]][license-url]
[![Downloads][downloads-image]][downloads-url]
[![npm badge][npm-badge-png]][package-url]
# 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);
});
test('test using promises', async function (t) {
const result = await someAsyncThing();
t.ok(result);
});
```
```
$ node example/timing.js
TAP version 13
# timing test
ok 1 should be strictly equal
not ok 2 should be strictly 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:
- [tap-spec](https://github.com/scottcorgan/tap-spec)
- [tap-dot](https://github.com/scottcorgan/tap-dot)
- [faucet](https://github.com/substack/faucet)
- [tap-bail](https://github.com/juliangruber/tap-bail)
- [tap-browser-color](https://github.com/kirbysayshi/tap-browser-color)
- [tap-json](https://github.com/gummesson/tap-json)
- [tap-min](https://github.com/derhuerst/tap-min)
- [tap-nyan](https://github.com/calvinmetcalf/tap-nyan)
- [tap-pessimist](https://www.npmjs.org/package/tap-pessimist)
- [tap-prettify](https://github.com/toolness/tap-prettify)
- [colortape](https://github.com/shuhei/colortape)
- [tap-xunit](https://github.com/aghassemi/tap-xunit)
- [tap-difflet](https://github.com/namuol/tap-difflet)
- [tape-dom](https://github.com/gritzko/tape-dom)
- [tap-diff](https://github.com/axross/tap-diff)
- [tap-notify](https://github.com/axross/tap-notify)
- [tap-summary](https://github.com/zoubin/tap-summary)
- [tap-markdown](https://github.com/Hypercubed/tap-markdown)
- [tap-html](https://github.com/gabrielcsapo/tap-html)
- [tap-react-browser](https://github.com/mcnuttandrew/tap-react-browser)
- [tap-junit](https://github.com/dhershman1/tap-junit)
- [tap-nyc](https://github.com/MegaArman/tap-nyc)
- [tap-spec (emoji patch)](https://github.com/Sceat/tap-spec-emoji)
- [tape-repeater](https://github.com/rgruesbeck/tape-repeater)
- [tabe](https://github.com/Josenzo/tabe)
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
- ES6 support with https://www.npmjs.com/package/babel-tape-runner or https://www.npmjs.com/package/buble-tape-runner
- Different test syntax with https://github.com/pguth/flip-tape (warning: mutates String.prototype)
- Electron test runner with https://github.com/tundrax/electron-tap
- Concurrency support with https://github.com/imsnif/mixed-tape
- In-process reporting with https://github.com/DavidAnson/tape-player
- Describe blocks with https://github.com/mattriley/tape-describe
# command-line flags
While running tests, top-level configurations can be passed via the command line to specify desired behavior.
Available configurations are listed below:
## --require
**Alias**: `-r`
This is used to load modules before running tests and is explained extensively in the [preloading modules](#preloading-modules) section.
## --ignore
**Alias**: `-i`
This flag is used when tests from certain folders and/or files are not intended to be run. It defaults to `.gitignore` file when passed with no argument.
```sh
tape -i .ignore **/*.js
```
An error is thrown if the specified file passed as argument does not exist.
## --no-only
This is particularly useful in a CI environment where an [only test](#testonlyname-opts-cb) is not supposed to go unnoticed.
By passing the `--no-only` flag, any existing [only test](#testonlyname-opts-cb) causes tests to fail.
```sh
tape --no-only **/*.js
```
Alternatively, the environment variable `NODE_TAPE_NO_ONLY_TEST` can be set to `true` to achieve the same behavior; the command-line flag takes precedence.
# methods
The assertion methods in `tape` are heavily influenced or copied from the methods in [node-tap](https://github.com/isaacs/node-tap).
```js
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.
- opts.todo = true/false. Test will be allowed to fail.
If you forget to `t.plan()` out how many assertions you are going to run and you don't call `t.end()` explicitly, or return a Promise that eventually settles, your test will hang.
If `cb` returns a Promise, it will be implicitly awaited. If that promise rejects, the test will be failed; if it fulfills, the test will end. Explicitly calling `t.end()` while also returning a Promise that fulfills is an error.
## test.skip([name], [opts], 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.
`fn` is called with no arguments, and its return value is ignored.
## test.onFailure(fn)
The onFailure hook will get invoked whenever any `tape` tests has failed.
`fn` is called with no arguments, and its return value is ignored.
## 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 falsy.
Do not call `t.end()` if your test callback returns a Promise.
## t.teardown(cb)
Register a callback to run after the individual test has completed. Multiple registered teardown callbacks will run in order. Useful for undoing side effects, closing network connections, etc.
## 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 `Object.is(actual, expected)` with an optional description of the assertion `msg`.
Aliases: `t.equals()`, `t.isEqual()`, `t.strictEqual()`, `t.strictEquals()`, `t.is()`
## t.notEqual(actual, expected, msg)
Assert that `!Object.is(actual, expected)` with an optional description of the assertion `msg`.
Aliases: `t.notEquals()`, `t.isNotEqual()`, `t.doesNotEqual()`, `t.isInequal()`, `t.notStrictEqual()`, `t.notStrictEquals()`, `t.isNot()`, `t.not()`
## t.looseEqual(actual, expected, msg)
Assert that `actual == expected` with an optional description of the assertion `msg`.
Aliases: `t.looseEquals()`
## t.notLooseEqual(actual, expected, msg)
Assert that `actual != expected` with an optional description of the assertion `msg`.
Aliases: `t.notLooseEquals()`
## 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.notDeepEquals`, `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`.
## 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`, `Function`, or `Object`. The `RegExp` matches the string representation of the exception, as generated by `err.toString()`. For example, if you set `expected` to `/user/`, the test will pass only if the string representation of the exception contains the word `user`. Any other exception will result in a failed test. The `Function` is the exception thrown (e.g. `Error`). `Object` in this case corresponds to a so-called validation object, in which each property is tested for strict deep equality. As an example, see the following two tests--each passes a validation object to `t.throws()` as the second parameter. The first test will pass, because all property values in the actual error object are deeply strictly equal to the property values in the validation object.
```
const err = new TypeError("Wrong value");
err.code = 404;
err.check = true;
// Passing test.
t.throws(
() => {
throw err;
},
{
code: 404,
check: true
},
"Test message."
);
```
This next test will fail, because all property values in the actual error object are _not_ deeply strictly equal to the property values in the validation object.
```
const err = new TypeError("Wrong value");
err.code = 404;
err.check = "true";
// Failing test.
t.throws(
() => {
throw err;
},
{
code: 404,
check: true // This is not deeply strictly equal to err.check.
},
"Test message."
);
```
This is very similar to how Node's `assert.throws()` method tests validation objects (please see the [Node _assert.throws()_ documentation](https://nodejs.org/api/assert.html#assert_assert_throws_fn_error_message) for more information).
If `expected` is not of type `RegExp`, `Function`, or `Object`, or omitted entirely, any exception will result in a passed test. `msg` is an optional description of the assertion.
Please note that the second parameter, `expected`, cannot be of type `string`. If a value of type `string` is provided for `expected`, then `t.throws(fn, expected, msg)` will execute, but the value of `expected` will be set to `undefined`, and the specified string will be set as the value for the `msg` parameter (regardless of what _actually_ passed as the third parameter). This can cause unexpected results, so please be mindful.
## t.doesNotThrow(fn, expected, msg)
Assert that the function call `fn()` does not throw an exception. `expected`, if present, limits what should not be thrown, and must be a `RegExp` or `Function`. The `RegExp` matches the string representation of the exception, as generated by `err.toString()`. For example, if you set `expected` to `/user/`, the test will fail only if the string representation of the exception contains the word `user`. Any other exception will result in a passed test. The `Function` is the exception thrown (e.g. `Error`). If `expected` is not of type `RegExp` or `Function`, or omitted entirely, any exception will result in a failed test. `msg` is an optional description of the assertion.
Please note that the second parameter, `expected`, cannot be of type `string`. If a value of type `string` is provided for `expected`, then `t.doesNotThrows(fn, expected, msg)` will execute, but the value of `expected` will be set to `undefined`, and the specified string will be set as the value for the `msg` parameter (regardless of what _actually_ passed as the third parameter). This can cause unexpected results, so please be mindful.
## 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.)
Multiline output will be split by `\n` characters, and each one printed as a comment.
## t.match(string, regexp, message)
Assert that `string` matches the RegExp `regexp`. Will fail when the first two arguments are the wrong type.
## t.doesNotMatch(string, regexp, message)
Assert that `string` does not match the RegExp `regexp`. Will fail when the first two arguments are the wrong type.
## 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], [opts], cb)
Like `test([name], [opts], 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.
Check out how the usage of [the --no-only flag](#--no-only) could help ensure there is no `.only` test running in a specified environment.
## 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:
```sh
$ node tap.js test/x.js test/y.js
TAP version 13
# (anonymous)
not ok 1 should be strictly equal
---
operator: equal
expected: "boop"
actual: "beep"
...
# (anonymous)
ok 2 should be strictly 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:
```sh
$ node object.js test/x.js test/y.js
{"type":"test","name":"(anonymous)","id":0}
{"id":0,"ok":false,"name":"should be strictly 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 strictly 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}
```
A convenient alternative to achieve the same:
```js
// report.js
var test = require('tape');
test.createStream({ objectMode: true }).on('data', function (row) {
console.log(JSON.stringify(row)) // for example
});
```
and then:
```sh
$ tape -r ./report.js **/*.test.js
```
# install
With [npm](https://npmjs.org) do:
```sh
npm install tape --save-dev
```
# troubleshooting
Sometimes `t.end()` doesn’t preserve the expected output ordering.
For instance the following:
```js
var test = require('tape');
test('first', function (t) {
setTimeout(function () {
t.ok(1, 'first test');
t.end();
}, 200);
t.test('second', function (t) {
t.ok(1, 'second test');
t.end();
});
});
test('third', function (t) {
setTimeout(function () {
t.ok(1, 'third test');
t.end();
}, 100);
});
```
will output:
```
ok 1 second test
ok 2 third test
ok 3 first test
```
because `second` and `third` assume `first` has ended before it actually does.
Use `t.plan()` instead to let other tests know they should wait:
```diff
var test = require('tape');
test('first', function (t) {
+ t.plan(2);
setTimeout(function () {
t.ok(1, 'first test');
- t.end();
}, 200);
t.test('second', function (t) {
t.ok(1, 'second test');
t.end();
});
});
test('third', function (t) {
setTimeout(function () {
t.ok(1, 'third test');
t.end();
}, 100);
});
```
# license
MIT
[package-url]: https://npmjs.org/package/tape
[npm-version-svg]: https://versionbadg.es/substack/tape.svg
[deps-svg]: https://david-dm.org/substack/tape.svg
[deps-url]: https://david-dm.org/substack/tape
[dev-deps-svg]: https://david-dm.org/substack/tape/dev-status.svg
[dev-deps-url]: https://david-dm.org/substack/tape#info=devDependencies
[npm-badge-png]: https://nodei.co/npm/tape.png?downloads=true&stars=true
[license-image]: https://img.shields.io/npm/l/tape.svg
[license-url]: LICENSE
[downloads-image]: https://img.shields.io/npm/dm/tape.svg
[downloads-url]: https://npm-stat.com/charts.html?package=tape
[codecov-image]: https://codecov.io/gh/substack/tape/branch/master/graphs/badge.svg
[codecov-url]: https://app.codecov.io/gh/substack/tape/
[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/substack/tape
[actions-url]: https://github.com/substack/tape/actions
tape-5.5.2/test/ 0000775 0000000 0000000 00000000000 14202055663 0013436 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/add-subtest-async.js 0000664 0000000 0000000 00000000365 14202055663 0017332 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
test('parent', function (t) {
t.pass('parent');
setTimeout(function () {
t.test('child', function (st) {
st.pass('child');
st.end();
});
}, 100);
});
tape-5.5.2/test/anonymous-fn.js 0000664 0000000 0000000 00000002435 14202055663 0016431 0 ustar 00root root 0000000 0000000 'use strict';
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'));
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',
''
]);
};
test.createStream().pipe(concat(tc));
test('wrapped test failure', testWrapper(function (t) {
t.fail('fail');
t.end();
}));
});
tape-5.5.2/test/anonymous-fn/ 0000775 0000000 0000000 00000000000 14202055663 0016067 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/anonymous-fn/test-wrapper.js 0000664 0000000 0000000 00000000447 14202055663 0021067 0 ustar 00root root 0000000 0000000 'use strict';
// 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-5.5.2/test/array.js 0000664 0000000 0000000 00000003063 14202055663 0015114 0 ustar 00root root 0000000 0000000 'use strict';
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 deeply equivalent',
'ok 2 should be deeply equivalent',
'ok 3 should be deeply equivalent',
'ok 4 should be deeply equivalent',
'ok 5 should be deeply 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-5.5.2/test/async-await.js 0000664 0000000 0000000 00000022725 14202055663 0016224 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var stripFullStack = require('./common').stripFullStack;
var runProgram = require('./common').runProgram;
var nodeVersion = process.versions.node;
var majorVersion = nodeVersion.split('.')[0];
if (Number(majorVersion) < 8) {
process.exit(0); // eslint-disable-line no-process-exit
}
var node17 = Number(majorVersion) >= 17;
var lengthMessage = 'Cannot read property \'length\' of null';
try {
lengthMessage = null.length;
} catch (e) {
lengthMessage = e.message; // differs in v8 6.9+ (node 16.9+)
}
tap.test('async1', function (t) {
runProgram('async-await', 'async1.js', function (r) {
t.deepEqual(stripFullStack(r.stdout.toString('utf8')), [
'TAP version 13',
'# async1',
'ok 1 before await',
'ok 2 after await',
'',
'1..2',
'# tests 2',
'# pass 2',
'',
'# ok',
'',
''
]);
t.same(r.exitCode, 0);
t.same(r.stderr.toString('utf8'), '');
t.end();
});
});
tap.test('async2', function (t) {
runProgram('async-await', 'async2.js', function (r) {
var stdout = r.stdout.toString('utf8');
var lines = stdout.split('\n').filter(function (line) {
return !(/^(\s+)at(\s+)$/).test(line);
});
t.deepEqual(stripFullStack(lines.join('\n')), [
'TAP version 13',
'# async2',
'ok 1 before await',
'not ok 2 after await',
' ---',
' operator: ok',
' expected: true',
' actual: false',
' at: Test.myTest ($TEST/async-await/async2.js:$LINE:$COL)',
' stack: |-',
' Error: after await',
' [... stack stripped ...]',
' at Test.myTest ($TEST/async-await/async2.js:$LINE:$COL)',
' ...',
'',
'1..2',
'# tests 2',
'# pass 1',
'# fail 1',
'',
''
]);
t.same(r.exitCode, 1);
t.same(r.stderr.toString('utf8'), '');
t.end();
});
});
tap.test('async3', function (t) {
runProgram('async-await', 'async3.js', function (r) {
t.deepEqual(stripFullStack(r.stdout.toString('utf8')), [
'TAP version 13',
'# async3',
'ok 1 before await',
'ok 2 after await',
'',
'1..2',
'# tests 2',
'# pass 2',
'',
'# ok',
'',
''
]);
t.same(r.exitCode, 0);
t.same(r.stderr.toString('utf8'), '');
t.end();
});
});
tap.test('async4', function (t) {
runProgram('async-await', 'async4.js', function (r) {
t.deepEqual(stripFullStack(r.stdout.toString('utf8')), [
'TAP version 13',
'# async4',
'ok 1 before await',
'not ok 2 Error: oops',
' ---',
' operator: error',
' at: Test.myTest ($TEST/async-await/async4.js:$LINE:$COL)',
' stack: |-',
' Error: oops',
' at Timeout.myTimeout [as _onTimeout] ($TEST/async-await/async4.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..2',
'# tests 2',
'# pass 1',
'# fail 1',
'',
''
]);
t.same(r.exitCode, 1);
t.same(r.stderr.toString('utf8'), '');
t.end();
});
});
tap.test('async5', function (t) {
runProgram('async-await', 'async5.js', function (r) {
t.same(stripFullStack(r.stdout.toString('utf8')), [
'TAP version 13',
'# async5',
'ok 1 before server',
'ok 2 after server',
'ok 3 before request',
'ok 4 after request',
'ok 5 res.statusCode is 200',
'not ok 6 .end() already called: mockDb.state is new',
' ---',
' operator: fail',
' at: Timeout._onTimeout ($TEST/async-await/async5.js:$LINE:$COL)',
' stack: |-',
' Error: .end() already called: mockDb.state is new',
' [... stack stripped ...]',
' at Timeout._onTimeout ($TEST/async-await/async5.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 7 .end() already called: error on close',
' ---',
' operator: fail',
' at: Server. ($TEST/async-await/async5.js:$LINE:$COL)',
' stack: |-',
' Error: .end() already called: error on close',
' [... stack stripped ...]',
' at Server. ($TEST/async-await/async5.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 8 .end() already called',
' ---',
' operator: fail',
' at: Server. ($TEST/async-await/async5.js:$LINE:$COL)',
' stack: |-',
' Error: .end() already called',
' [... stack stripped ...]',
' at Server. ($TEST/async-await/async5.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..8',
'# tests 8',
'# pass 5',
'# fail 3',
'',
''
]);
t.same(r.exitCode, 1);
t.same(r.stderr.toString('utf8'), '');
t.end();
});
});
tap.test('sync-error', function (t) {
runProgram('async-await', 'sync-error.js', function (r) {
t.same(stripFullStack(r.stdout.toString('utf8')), [
'TAP version 13',
'# sync-error',
'ok 1 before throw',
''
]);
t.same(r.exitCode, 1);
var stderr = r.stderr.toString('utf8');
var lines = stderr.split('\n');
lines = lines.filter(function (line) {
return !(/\(timers.js:/).test(line)
&& !(/\(internal\/timers.js:/).test(line)
&& !(/Immediate\.next/).test(line);
});
stderr = lines.join('\n');
t.same(stripFullStack(stderr), [].concat(
'$TEST/async-await/sync-error.js:7',
' throw new Error(\'oopsie\');',
' ^',
'',
'Error: oopsie',
' at Test.myTest ($TEST/async-await/sync-error.js:$LINE:$COL)',
' at Test.bound [as _cb] ($TAPE/lib/test.js:$LINE:$COL)',
' at Test.run ($TAPE/lib/test.js:$LINE:$COL)',
' at Test.bound [as run] ($TAPE/lib/test.js:$LINE:$COL)',
node17 ? [
'',
'Node.js ' + process.version
] : [],
''
));
t.end();
});
});
tap.test('async-error', function (t) {
runProgram('async-await', 'async-error.js', function (r) {
var stdout = r.stdout.toString('utf8');
var lines = stdout.split('\n');
lines = lines.filter(function (line) {
return !(/^(\s+)at(\s+)$/).test(line);
});
stdout = lines.join('\n');
t.same(stripFullStack(stdout), [
'TAP version 13',
'# async-error',
'ok 1 before throw',
'not ok 2 Error: oopsie',
' ---',
' operator: error',
' stack: |-',
' Error: oopsie',
' at Test.myTest ($TEST/async-await/async-error.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..2',
'# tests 2',
'# pass 1',
'# fail 1',
'',
''
]);
t.same(r.exitCode, 1);
var stderr = r.stderr.toString('utf8');
var stderrLines = stderr.split('\n').filter(function (line) {
return !(/\(timers.js:/).test(line)
&& !(/\(internal\/timers.js:/).test(line)
&& !(/Immediate\.next/).test(line);
});
t.same(stderrLines.join('\n'), '');
t.end();
});
});
tap.test('async-bug', function (t) {
runProgram('async-await', 'async-bug.js', function (r) {
var stdout = r.stdout.toString('utf8');
var lines = stdout.split('\n');
lines = lines.filter(function (line) {
return !(/^(\s+)at(\s+)$/).test(line);
});
stdout = lines.join('\n');
t.same(stripFullStack(stdout), [
'TAP version 13',
'# async-error',
'ok 1 before throw',
'ok 2 should be strictly equal',
'not ok 3 TypeError: ' + lengthMessage,
' ---',
' operator: error',
' stack: |-',
' TypeError: ' + lengthMessage,
' at myCode ($TEST/async-await/async-bug.js:$LINE:$COL)',
' at Test.myTest ($TEST/async-await/async-bug.js:$LINE:$COL)',
' ...',
'',
'1..3',
'# tests 3',
'# pass 2',
'# fail 1',
'',
''
]);
t.same(r.exitCode, 1);
var stderr = r.stderr.toString('utf8');
t.same(stderr, '');
t.end();
});
});
tape-5.5.2/test/async-await/ 0000775 0000000 0000000 00000000000 14202055663 0015656 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/async-await/async-bug.js 0000664 0000000 0000000 00000001040 14202055663 0020077 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
function myCode(arr) {
let sum = 0;
// oops forgot to handle null
for (let i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
test('async-error', async function myTest(t) {
await sleep(100);
t.ok(true, 'before throw');
const sum = myCode([1, 2, 3]);
t.equal(sum, 6);
const sum2 = myCode(null);
t.equal(sum2, 0);
t.end();
});
function sleep(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
tape-5.5.2/test/async-await/async-error.js 0000664 0000000 0000000 00000000342 14202055663 0020457 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('async-error', async function myTest(t) {
t.ok(true, 'before throw');
throw new Error('oopsie');
/* eslint no-unreachable: 0 */
t.ok(true, 'after throw');
});
tape-5.5.2/test/async-await/async1.js 0000664 0000000 0000000 00000000512 14202055663 0017410 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('async1', async function myTest(t) {
try {
t.ok(true, 'before await');
await new Promise((resolve) => {
setTimeout(resolve, 10);
});
t.ok(true, 'after await');
t.end();
} catch (err) {
t.ifError(err);
}
});
tape-5.5.2/test/async-await/async2.js 0000664 0000000 0000000 00000000472 14202055663 0017416 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('async2', async function myTest(t) {
try {
t.ok(true, 'before await');
await new Promise((resolve) => {
setTimeout(resolve, 10);
});
t.ok(false, 'after await');
} catch (err) {
t.ifError(err);
}
});
tape-5.5.2/test/async-await/async3.js 0000664 0000000 0000000 00000000351 14202055663 0017413 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('async3', async function myTest(t) {
t.ok(true, 'before await');
await new Promise((resolve) => {
setTimeout(resolve, 10);
});
t.ok(true, 'after await');
});
tape-5.5.2/test/async-await/async4.js 0000664 0000000 0000000 00000000611 14202055663 0017413 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('async4', async function myTest(t) {
try {
t.ok(true, 'before await');
await new Promise((resolve, reject) => {
setTimeout(function myTimeout() {
reject(new Error('oops'));
}, 10);
});
t.ok(true, 'after await');
} catch (err) {
t.ifError(err);
}
});
tape-5.5.2/test/async-await/async5.js 0000664 0000000 0000000 00000002701 14202055663 0017416 0 ustar 00root root 0000000 0000000 'use strict';
var util = require('util');
var http = require('http');
var test = require('../../');
test('async5', async function myTest(t) {
try {
t.ok(true, 'before server');
var mockDb = { state: 'old' };
var server = http.createServer(function (req, res) {
res.end('OK');
// Pretend we write to the DB and it takes time.
setTimeout(function () {
mockDb.state = 'new';
}, 10);
});
await util.promisify(function (cb) {
server.listen(0, cb);
})();
t.ok(true, 'after server');
t.ok(true, 'before request');
var res = await util.promisify(function (cb) {
var req = http.request({
hostname: 'localhost',
port: server.address().port,
path: '/',
method: 'GET'
}, function (resp) {
cb(null, resp);
});
req.end();
})();
t.ok(true, 'after request');
res.resume();
t.equal(res.statusCode, 200, 'res.statusCode is 200');
setTimeout(function () {
t.equal(mockDb.state, 'new', 'mockDb.state is new');
server.close(function (err) {
t.ifError(err, 'error on close');
t.end();
});
}, 50);
} catch (err) {
t.ifError(err, 'error in catch');
t.end();
}
});
tape-5.5.2/test/async-await/sync-error.js 0000664 0000000 0000000 00000000350 14202055663 0020315 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('sync-error', function myTest(t) {
t.ok(true, 'before throw');
throw new Error('oopsie');
/* eslint no-unreachable: 0 */
t.ok(true, 'after throw');
t.end();
});
tape-5.5.2/test/bound.js 0000664 0000000 0000000 00000000321 14202055663 0015077 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/browser/ 0000775 0000000 0000000 00000000000 14202055663 0015121 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/browser/asserts.js 0000664 0000000 0000000 00000000344 14202055663 0017144 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/child_ordering.js 0000664 0000000 0000000 00000002637 14202055663 0016760 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
var childRan = false;
test('parent', function (t) {
t.test('child', function (st) {
childRan = true;
st.pass('child ran');
st.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 (st) {
st.ok(!parentRan, 'parent ran twice');
parentRan = true;
st.test('grandchild', function (s2t) {
s2t.ok(!grandChildRan, 'grand child ran twice');
grandChildRan = true;
s2t.pass('grand child ran');
s2t.end();
});
st.pass('parent ran');
st.end();
});
t.test('other parent', function (st) {
st.ok(parentRan, 'first parent runs before second parent');
st.ok(grandChildRan, 'grandchild runs before second parent');
st.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-5.5.2/test/circular-things.js 0000664 0000000 0000000 00000002535 14202055663 0017077 0 ustar 00root root 0000000 0000000 'use strict';
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.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# circular',
'not ok 1 should be strictly equal',
' ---',
' operator: equal',
' expected: |-',
' {}',
' actual: |-',
' { circular: [Circular] }',
' at: Test. ($TEST/circular-things.js:$LINE:$COL)',
' stack: |-',
' Error: should be strictly equal',
' [... stack stripped ...]',
' at Test. ($TEST/circular-things.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
}));
test('circular', function (t) {
t.plan(1);
var circular = {};
circular.circular = circular;
t.equal(circular, {});
});
});
tape-5.5.2/test/comment.js 0000664 0000000 0000000 00000011103 14202055663 0015432 0 ustar 00root root 0000000 0000000 'use strict';
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.deepEqual(output.toString('utf8').split('\n'), [
'TAP version 13',
'# no comment',
'',
'1..0',
'# tests 0',
'# pass 0',
'',
'# ok',
''
]);
};
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();
});
});
tap.test('comment with createStream/objectMode', function (assert) {
assert.plan(1);
var test = tape.createHarness();
test.createStream({ objectMode: true }).on('data', function (row) {
if (typeof row === 'string') {
assert.equal(row, 'comment message');
}
});
test('t.comment', function (t) {
t.comment('comment message');
t.end();
});
});
tape-5.5.2/test/common.js 0000664 0000000 0000000 00000007513 14202055663 0015272 0 ustar 00root root 0000000 0000000 'use strict';
var path = require('path');
var spawn = require('child_process').spawn;
var concat = require('concat-stream');
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 placeholder
// $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.
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;
};
module.exports.stripFullStack = function (output) {
var stripped = ' [... stack stripped ...]';
var withDuplicates = output.split(/\r?\n/g).map(stripChangingData).map(function (line) {
var m = line.match(/[ ]{8}at .*\((.*)\)/);
if (m && m[1].slice(0, 5) !== '$TEST') {
return stripped;
}
return line;
});
var withoutInternals = withDuplicates.filter(function (line) {
return !line.match(/ \(node:[^)]+\)$/);
});
var deduped = withoutInternals.filter(function (line, ix) {
var hasPrior = line === stripped && withDuplicates[ix - 1] === stripped;
return !hasPrior;
});
return deduped.join('\n').replace(
// Handle stack trace variation in Node v0.8
/at(:?) Test\.(?:module\.exports|tap\.test\.err\.code)/g,
'at$1 Test.'
).replace(
// Handle stack trace variation in Node v0.8
/at(:?) (Test\.)?tap\.test\.test\.skip/g,
'at$1 $2'
).replace(
// Handle stack trace variation in Node v0.8
/(\[\.\.\. stack stripped \.\.\.\]\r?\n *at) \(([^)]+)\)/g,
'$1 $2'
).split(/\r?\n/g);
};
module.exports.runProgram = function (folderName, fileName, cb) {
var result = {
stdout: null,
stderr: null,
exitCode: 0
};
var ps = spawn(process.execPath, [
path.join(__dirname, folderName, fileName)
]);
ps.stdout.pipe(concat(function (stdoutRows) {
result.stdout = stdoutRows;
}));
ps.stderr.pipe(concat(function (stderrRows) {
result.stderr = stderrRows;
}));
ps.on('exit', function (code) {
result.exitCode = code;
cb(result);
});
};
tape-5.5.2/test/create_multiple_streams.js 0000664 0000000 0000000 00000001300 14202055663 0020702 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../');
tape.test('createMultipleStreams', function (tt) {
tt.plan(2);
var th = tape.createHarness();
th.createStream();
th.createStream();
var testOneComplete = false;
th('test one', function (tht) {
tht.plan(1);
setTimeout(function () {
tht.pass();
testOneComplete = true;
}, 100);
});
th('test two', function (tht) {
tht.ok(testOneComplete, 'test 1 completed before test 2');
tht.end();
});
th.onFinish(function () {
tt.equal(th._results.count, 2, 'harness test ran');
tt.equal(th._results.fail, 0, "harness test didn't fail");
});
});
tape-5.5.2/test/deep-equal-failure.js 0000664 0000000 0000000 00000014524 14202055663 0017451 0 ustar 00root root 0000000 0000000 'use strict';
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.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# deep equal',
'not ok 1 should be strictly equal',
' ---',
' operator: equal',
' expected: |-',
' { b: 2 }',
' actual: |-',
' { a: 1 }',
' at: Test. ($TEST/deep-equal-failure.js:$LINE:$COL)',
' stack: |-',
' Error: should be strictly equal',
' [... stack stripped ...]',
' at Test. ($TEST/deep-equal-failure.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
assert.deepEqual(getDiag(body), {
operator: 'equal',
expected: '{ b: 2 }',
actual: '{ a: 1 }'
});
}));
parser.once('assert', function (data) {
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should be strictly equal',
diag: {
operator: 'equal',
expected: '{ b: 2 }',
actual: '{ a: 1 }',
// we don't care about these next two
stack: data.diag.stack,
at: data.diag.at
}
});
});
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.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# deep equal',
'not ok 1 should be strictly equal',
' ---',
' operator: equal',
' expected: |-',
' { a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } }',
' actual: |-',
' { a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
' at: Test. ($TEST/deep-equal-failure.js:$LINE:$COL)',
' stack: |-',
' Error: should be strictly equal',
' [... stack stripped ...]',
' at Test. ($TEST/deep-equal-failure.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
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) {
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should be strictly equal',
diag: {
operator: 'equal',
expected: '{ a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
// we don't care about these next two
stack: data.diag.stack,
at: data.diag.at
}
});
});
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.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# deep equal',
'not ok 1 should be strictly equal',
' ---',
' operator: equal',
' expected: |-',
' { a: { a1: { a2: { a3: { a4: [Object] } } } } }',
' actual: |-',
' { a: { a1: { a2: { a3: { a4: [Object] } } } } }',
' at: Test. ($TEST/deep-equal-failure.js:$LINE:$COL)',
' stack: |-',
' Error: should be strictly equal',
' [... stack stripped ...]',
' at Test. ($TEST/deep-equal-failure.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
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) {
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should be strictly equal',
diag: {
operator: 'equal',
expected: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
// we don't care about these next two
stack: data.diag.stack,
at: data.diag.at
}
});
});
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-5.5.2/test/deep.js 0000664 0000000 0000000 00000002562 14202055663 0014716 0 ustar 00root root 0000000 0000000 'use strict';
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();
});
test('requires 2 arguments', function (t) {
var err = /^TypeError: two arguments must be provided/;
t.throws(function () { t.deepEqual(); }, err, 'deepEqual: no args');
t.throws(function () { t.deepEqual(undefined); }, err, 'deepEqual: one arg');
t.throws(function () { t.deepLooseEqual(); }, err, 'deepLooseEqual: no args');
t.throws(function () { t.deepLooseEqual(undefined); }, err, 'deepLooseEqual: one arg');
t.throws(function () { t.notDeepEqual(); }, err, 'notDeepEqual: no args');
t.throws(function () { t.notDeepEqual(undefined); }, err, 'notDeepEqual: one arg');
t.throws(function () { t.notDeepLooseEqual(); }, err, 'notDeepLooseEqual: no args');
t.throws(function () { t.notDeepLooseEqual(undefined); }, err, 'notDeepLooseEqual: one arg');
t.throws(function () { t.equal(); }, err, 'equal: no args');
t.throws(function () { t.equal(undefined); }, err, 'equal: one arg');
t.throws(function () { t.notEqual(); }, err, 'notEqual: no args');
t.throws(function () { t.notEqual(undefined); }, err, 'notEqual: one arg');
t.end();
});
tape-5.5.2/test/default-messages.js 0000664 0000000 0000000 00000003361 14202055663 0017230 0 ustar 00root root 0000000 0000000 'use strict';
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('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(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# default messages',
'ok 1 should be truthy',
'ok 2 should be falsy',
'ok 3 should be strictly equal',
'ok 4 should not be strictly equal',
'ok 5 should be loosely equal',
'ok 6 should not be loosely equal',
'ok 7 should be strictly equal',
'ok 8 should not be strictly equal',
'ok 9 should be deeply equivalent',
'not ok 10 should not be deeply equivalent',
' ---',
' operator: notDeepEqual',
' expected: true',
' actual: true',
' at: Test. ($TEST/messages/defaults.js:$LINE:$COL)',
' stack: |-',
' Error: should not be deeply equivalent',
' [... stack stripped ...]',
' at Test. ($TEST/messages/defaults.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 11 should be loosely deeply equivalent',
'ok 12 should not be loosely deeply equivalent',
'',
'1..12',
'# tests 12',
'# pass 11',
'# fail 1',
'',
''
]);
}));
});
tape-5.5.2/test/double_end.js 0000664 0000000 0000000 00000004005 14202055663 0016073 0 ustar 00root root 0000000 0000000 'use strict';
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 (tt) {
tt.plan(2);
var ps = spawn(process.execPath, [path.join(__dirname, 'double_end', 'double.js')]);
ps.on('exit', function (code) {
tt.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)[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'));
tt.same(stripped, [
'TAP version 13',
'# double end',
'ok 1 should be strictly equal',
'not ok 2 .end() already called',
' ---',
' operator: fail',
' ' + atExpected,
' stack: |-',
' Error: .end() already called',
' [... stack stripped ...]',
' ' + stackExpected,
' [... stack stripped ...]',
' ...',
'',
'1..2',
'# tests 2',
'# pass 1',
'# fail 1',
'',
''
]);
}));
});
tape-5.5.2/test/double_end/ 0000775 0000000 0000000 00000000000 14202055663 0015536 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/double_end/double.js 0000664 0000000 0000000 00000000301 14202055663 0017340 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('double end', function (t) {
function doEnd() {
t.end();
}
t.equal(1 + 1, 2);
t.end();
setTimeout(doEnd, 5);
});
tape-5.5.2/test/edge-cases.js 0000664 0000000 0000000 00000026051 14202055663 0016000 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('edge cases', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream().pipe(concat(function (body) {
tt.same(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# zeroes',
'not ok 1 0 equal to -0',
' ---',
' operator: equal',
' expected: |-',
' -0',
' actual: |-',
' 0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: 0 equal to -0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 2 -0 equal to 0',
' ---',
' operator: equal',
' expected: |-',
' 0',
' actual: |-',
' -0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: -0 equal to 0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 3 0 notEqual to -0',
'ok 4 -0 notEqual to 0',
'ok 5 0 looseEqual to -0',
'ok 6 -0 looseEqual to 0',
'not ok 7 0 notLooseEqual to -0',
' ---',
' operator: notLooseEqual',
' expected: |-',
' -0',
' actual: |-',
' 0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: 0 notLooseEqual to -0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 8 -0 notLooseEqual to 0',
' ---',
' operator: notLooseEqual',
' expected: |-',
' 0',
' actual: |-',
' -0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: -0 notLooseEqual to 0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 9 0 strictEqual to -0',
' ---',
' operator: equal',
' expected: |-',
' -0',
' actual: |-',
' 0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: 0 strictEqual to -0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 10 -0 strictEqual to 0',
' ---',
' operator: equal',
' expected: |-',
' 0',
' actual: |-',
' -0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: -0 strictEqual to 0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 11 0 notStrictEqual to -0',
'ok 12 -0 notStrictEqual to 0',
'ok 13 0 deepLooseEqual to -0',
'ok 14 -0 deepLooseEqual to 0',
'not ok 15 0 notDeepLooseEqual to -0',
' ---',
' operator: notDeepLooseEqual',
' expected: |-',
' -0',
' actual: |-',
' 0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: 0 notDeepLooseEqual to -0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 16 -0 notDeepLooseEqual to 0',
' ---',
' operator: notDeepLooseEqual',
' expected: |-',
' 0',
' actual: |-',
' -0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: -0 notDeepLooseEqual to 0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 17 0 deepEqual to -0',
' ---',
' operator: deepEqual',
' expected: |-',
' -0',
' actual: |-',
' 0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: 0 deepEqual to -0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 18 -0 deepEqual to 0',
' ---',
' operator: deepEqual',
' expected: |-',
' 0',
' actual: |-',
' -0',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: -0 deepEqual to 0',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 19 0 notDeepEqual to -0',
'ok 20 -0 notDeepEqual to 0',
'# NaNs',
'ok 21 NaN equal to NaN',
'not ok 22 NaN notEqual to NaN',
' ---',
' operator: notEqual',
' expected: NaN',
' actual: NaN',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: NaN notEqual to NaN',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 23 NaN looseEqual to NaN',
' ---',
' operator: looseEqual',
' expected: NaN',
' actual: NaN',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: NaN looseEqual to NaN',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 24 NaN notLooseEqual to NaN',
'ok 25 NaN strictEqual to NaN',
'not ok 26 NaN notStrictEqual to NaN',
' ---',
' operator: notEqual',
' expected: NaN',
' actual: NaN',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: NaN notStrictEqual to NaN',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 27 NaN deepLooseEqual to NaN',
' ---',
' operator: deepLooseEqual',
' expected: NaN',
' actual: NaN',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: NaN deepLooseEqual to NaN',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 28 NaN notDeepLooseEqual to NaN',
'ok 29 NaN deepEqual to NaN',
'not ok 30 NaN notDeepEqual to NaN',
' ---',
' operator: notDeepEqual',
' expected: NaN',
' actual: NaN',
' at: Test. ($TEST/edge-cases.js:$LINE:$COL)',
' stack: |-',
' Error: NaN notDeepEqual to NaN',
' [... stack stripped ...]',
' at Test. ($TEST/edge-cases.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..30',
'# tests 30',
'# pass 15',
'# fail 15',
''
]);
}));
test('zeroes', function (t) {
t.equal(0, -0, '0 equal to -0');
t.equal(-0, 0, '-0 equal to 0');
t.notEqual(0, -0, '0 notEqual to -0');
t.notEqual(-0, 0, '-0 notEqual to 0');
t.looseEqual(0, -0, '0 looseEqual to -0');
t.looseEqual(-0, 0, '-0 looseEqual to 0');
t.notLooseEqual(0, -0, '0 notLooseEqual to -0');
t.notLooseEqual(-0, 0, '-0 notLooseEqual to 0');
t.strictEqual(0, -0, '0 strictEqual to -0');
t.strictEqual(-0, 0, '-0 strictEqual to 0');
t.notStrictEqual(0, -0, '0 notStrictEqual to -0');
t.notStrictEqual(-0, 0, '-0 notStrictEqual to 0');
t.deepLooseEqual(0, -0, '0 deepLooseEqual to -0');
t.deepLooseEqual(-0, 0, '-0 deepLooseEqual to 0');
t.notDeepLooseEqual(0, -0, '0 notDeepLooseEqual to -0');
t.notDeepLooseEqual(-0, 0, '-0 notDeepLooseEqual to 0');
t.deepEqual(0, -0, '0 deepEqual to -0');
t.deepEqual(-0, 0, '-0 deepEqual to 0');
t.notDeepEqual(0, -0, '0 notDeepEqual to -0');
t.notDeepEqual(-0, 0, '-0 notDeepEqual to 0');
t.end();
});
test('NaNs', function (t) {
t.equal(NaN, NaN, 'NaN equal to NaN');
t.notEqual(NaN, NaN, 'NaN notEqual to NaN');
t.looseEqual(NaN, NaN, 'NaN looseEqual to NaN');
t.notLooseEqual(NaN, NaN, 'NaN notLooseEqual to NaN');
t.strictEqual(NaN, NaN, 'NaN strictEqual to NaN');
t.notStrictEqual(NaN, NaN, 'NaN notStrictEqual to NaN');
t.deepLooseEqual(NaN, NaN, 'NaN deepLooseEqual to NaN');
t.notDeepLooseEqual(NaN, NaN, 'NaN notDeepLooseEqual to NaN');
t.deepEqual(NaN, NaN, 'NaN deepEqual to NaN');
t.notDeepEqual(NaN, NaN, 'NaN notDeepEqual to NaN');
t.end();
});
});
tape-5.5.2/test/end-as-callback.js 0000664 0000000 0000000 00000004552 14202055663 0016703 0 ustar 00root root 0000000 0000000 'use strict';
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 strictly equal',
'# do a task and write fail',
'ok 3 null',
'ok 4 should be strictly 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-5.5.2/test/error.js 0000664 0000000 0000000 00000002062 14202055663 0015125 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('failures', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream().pipe(concat(function (body) {
tt.same(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# error',
'not ok 1 Error: this is a message',
' ---',
' operator: error',
' at: Test. ($TEST/error.js:$LINE:$COL)',
' stack: |-',
' Error: this is a message',
' at Test. ($TEST/error.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
}));
test('error', function (t) {
t.plan(1);
t.error(new Error('this is a message'));
});
});
tape-5.5.2/test/exit.js 0000664 0000000 0000000 00000016300 14202055663 0014745 0 ustar 00root root 0000000 0000000 'use strict';
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 deeply equivalent',
'ok 2 should be deeply equivalent',
'ok 3 should be deeply equivalent',
'ok 4 should be deeply equivalent',
'ok 5 should be deeply 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 deeply equivalent',
'ok 2 should be deeply equivalent',
'ok 3 should be deeply equivalent',
'ok 4 should be deeply equivalent',
'not ok 5 should be deeply 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 deeply 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',
'',
''
]);
};
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 deeply equivalent',
'ok 2 should be deeply equivalent',
'ok 3 should be deeply equivalent',
'ok 4 should be deeply equivalent',
'ok 5 should be deeply 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',
'',
''
]);
};
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',
'',
''
]);
};
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);
});
});
tap.test('todo passing', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# TODO todo pass',
'ok 1 should be truthy # TODO',
'',
'1..1',
'# tests 1',
'# pass 1',
'',
'# ok',
'',
''
]);
};
var ps = spawn(process.execPath, [path.join(__dirname, '/exit/todo.js')]);
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.equal(code, 0);
});
});
tap.test('todo failing', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# TODO todo fail',
'not ok 1 should be truthy # TODO',
' ---',
' operator: ok',
' expected: true',
' actual: false',
' at: Test. ($TEST/exit/todo_fail.js:$LINE:$COL)',
' ...',
'',
'1..1',
'# tests 1',
'# pass 1',
'',
'# ok',
'',
''
]);
};
var ps = spawn(process.execPath, [path.join(__dirname, '/exit/todo_fail.js')]);
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.equal(code, 0);
});
});
tap.test('forgot to call t.end()', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# first',
'ok 1 should be truthy',
'# oops forgot end',
'ok 2 should be truthy',
'not ok 3 test exited without ending: oops forgot end',
' ---',
' operator: fail',
' at: process. ($TAPE/index.js:$LINE:$COL)',
' stack: |-',
' Error: test exited without ending: oops forgot end',
' [... stack stripped ...]',
' ...',
'',
'1..3',
'# tests 3',
'# pass 2',
'# fail 1',
'',
''
]);
};
var ps = spawn(process.execPath, [path.join(__dirname, '/exit/missing_end.js')]);
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
t.notEqual(code, 0);
});
});
tape-5.5.2/test/exit/ 0000775 0000000 0000000 00000000000 14202055663 0014407 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/exit/fail.js 0000664 0000000 0000000 00000001401 14202055663 0015654 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/exit/missing_end.js 0000664 0000000 0000000 00000000250 14202055663 0017241 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('first', function (t) {
t.ok(true);
t.end();
});
test('oops forgot end', function (t) {
t.ok(true);
});
tape-5.5.2/test/exit/ok.js 0000664 0000000 0000000 00000001423 14202055663 0015356 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/exit/second.js 0000664 0000000 0000000 00000000260 14202055663 0016216 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('first', function (t) {
t.plan(1);
t.ok(true);
});
test('second', function (t) {
t.plan(2);
t.ok(true);
});
tape-5.5.2/test/exit/todo.js 0000664 0000000 0000000 00000000202 14202055663 0015704 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('todo pass', { todo: true }, function (t) {
t.plan(1);
t.ok(true);
});
tape-5.5.2/test/exit/todo_fail.js 0000664 0000000 0000000 00000000203 14202055663 0016700 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('todo fail', { todo: true }, function (t) {
t.plan(1);
t.ok(false);
});
tape-5.5.2/test/exit/too_few.js 0000664 0000000 0000000 00000001376 14202055663 0016416 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/exposed-harness.js 0000664 0000000 0000000 00000000453 14202055663 0017106 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/fail.js 0000664 0000000 0000000 00000004577 14202055663 0014724 0 ustar 00root root 0000000 0000000 'use strict';
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 deeply equivalent',
'ok 2 should be deeply equivalent',
'ok 3 should be deeply equivalent',
'ok 4 should be deeply equivalent',
'not ok 5 should be deeply 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 deeply 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',
''
]);
};
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-5.5.2/test/has spaces.js 0000664 0000000 0000000 00000002166 14202055663 0016013 0 ustar 00root root 0000000 0000000 'use strict';
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',
''
]);
};
test.createStream().pipe(concat(tc));
test('fail', function (t) {
t.fail('this should fail');
t.end();
});
});
tape-5.5.2/test/ignore/ 0000775 0000000 0000000 00000000000 14202055663 0014721 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/ignore/.ignore 0000664 0000000 0000000 00000000022 14202055663 0016177 0 ustar 00root root 0000000 0000000 fake_node_modules
tape-5.5.2/test/ignore/fake_node_modules/ 0000775 0000000 0000000 00000000000 14202055663 0020364 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/ignore/fake_node_modules/stub1.js 0000664 0000000 0000000 00000000175 14202055663 0021763 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../../');
tape.test(function (t) {
t.plan(1);
t.fail('Should not print');
});
tape-5.5.2/test/ignore/fake_node_modules/stub2.js 0000664 0000000 0000000 00000000173 14202055663 0021762 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../../');
tape.test(function (t) {
t.fail('Should not print');
t.end();
});
tape-5.5.2/test/ignore/test.js 0000664 0000000 0000000 00000000154 14202055663 0016236 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../');
tape.test(function (t) {
t.plan(1);
t.ok('Okay');
});
tape-5.5.2/test/ignore/test/ 0000775 0000000 0000000 00000000000 14202055663 0015700 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/ignore/test/stub1.js 0000664 0000000 0000000 00000000167 14202055663 0017300 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../../');
tape.test(function (t) {
t.plan(1);
t.pass('test/stub1');
});
tape-5.5.2/test/ignore/test/stub2.js 0000664 0000000 0000000 00000000165 14202055663 0017277 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../../');
tape.test(function (t) {
t.pass('test/stub2');
t.end();
});
tape-5.5.2/test/ignore/test/sub/ 0000775 0000000 0000000 00000000000 14202055663 0016471 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/ignore/test/sub/sub.stub1.js 0000664 0000000 0000000 00000000176 14202055663 0020661 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../../../');
tape.test(function (t) {
t.plan(1);
t.pass('test/sub/stub1');
});
tape-5.5.2/test/ignore/test/sub/sub.stub2.js 0000664 0000000 0000000 00000000174 14202055663 0020660 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../../../');
tape.test(function (t) {
t.pass('test/sub/stub2');
t.end();
});
tape-5.5.2/test/ignore/test2.js 0000664 0000000 0000000 00000000164 14202055663 0016321 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../');
tape.test(function (t) {
t.pass('Should print');
t.end();
});
tape-5.5.2/test/ignore_from_gitignore.js 0000664 0000000 0000000 00000007467 14202055663 0020367 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var path = require('path');
var spawn = require('child_process').spawn;
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
var tapeBin = path.join(process.cwd(), 'bin/tape');
tap.test('Should pass with ignoring', { skip: process.platform === 'win32' }, function (tt) {
tt.plan(2);
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# (anonymous)',
'ok 1 should be truthy',
'# (anonymous)',
'ok 2 test/stub1',
'# (anonymous)',
'ok 3 test/stub2',
'# (anonymous)',
'ok 4 test/sub/stub1',
'# (anonymous)',
'ok 5 test/sub/stub2',
'# (anonymous)',
'ok 6 Should print',
'',
'1..6',
'# tests 6',
'# pass 6',
'',
'# ok',
'',
''
]);
};
var ps = spawn(tapeBin, ['**/*.js', '-i', '.ignore'], { cwd: path.join(__dirname, 'ignore') });
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
tt.equal(code, 0); // code 0
});
});
tap.test('Should pass', { skip: process.platform === 'win32' }, function (tt) {
tt.plan(2);
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# (anonymous)',
'not ok 1 Should not print',
' ---',
' operator: fail',
' at: Test. ($TEST/ignore/fake_node_modules/stub1.js:$LINE:$COL)',
' stack: |-',
' Error: Should not print',
' [... stack stripped ...]',
' at Test. ($TEST/ignore/fake_node_modules/stub1.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'# (anonymous)',
'not ok 2 Should not print',
' ---',
' operator: fail',
' at: Test. ($TEST/ignore/fake_node_modules/stub2.js:$LINE:$COL)',
' stack: |-',
' Error: Should not print',
' [... stack stripped ...]',
' at Test. ($TEST/ignore/fake_node_modules/stub2.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'# (anonymous)',
'ok 3 should be truthy',
'# (anonymous)',
'ok 4 test/stub1',
'# (anonymous)',
'ok 5 test/stub2',
'# (anonymous)',
'ok 6 test/sub/stub1',
'# (anonymous)',
'ok 7 test/sub/stub2',
'# (anonymous)',
'ok 8 Should print',
'',
'1..8',
'# tests 8',
'# pass 6',
'# fail 2',
'',
''
]);
};
var ps = spawn(tapeBin, ['**/*.js'], { cwd: path.join(__dirname, 'ignore') });
ps.stdout.pipe(concat(tc));
ps.on('exit', function (code) {
tt.equal(code, 1);
});
});
tap.test('Should fail when ignore file does not exist', { skip: process.platform === 'win32' }, function (tt) {
tt.plan(3);
var testStdout = function (rows) {
tt.same(rows.toString('utf8'), '');
};
var testStderr = function (rows) {
tt.ok((/^ENOENT[:,] no such file or directory,? (?:open )?'\$TEST\/ignore\/.gitignore'\n$/m).test(stripFullStack(rows.toString('utf8')).join('\n')));
};
var ps = spawn(tapeBin, ['**/*.js', '-i'], { cwd: path.join(__dirname, 'ignore') });
ps.stdout.pipe(concat(testStdout));
ps.stderr.pipe(concat(testStderr));
ps.on('exit', function (code) {
tt.equal(code, 2);
});
});
tape-5.5.2/test/import.js 0000664 0000000 0000000 00000015445 14202055663 0015317 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var spawn = require('child_process').spawn;
var concat = require('concat-stream');
var hasDynamicImport = require('has-dynamic-import');
var assign = require('object.assign');
tap.test('importing mjs files', function (t) {
hasDynamicImport().then(function (hasSupport) {
if (hasSupport) {
var tc = function (rows) {
t.same(rows.toString('utf8'), [
'TAP version 13',
'# mjs-a',
'ok 1 test ran',
'# mjs-b',
'ok 2 test ran after mjs-a',
'# mjs-c',
'ok 3 test ran after mjs-b',
'# mjs-d',
'ok 4 test ran after mjs-c',
'# mjs-e',
'ok 5 test ran after mjs-d',
'# mjs-f',
'ok 6 test ran after mjs-e',
'# mjs-g',
'ok 7 test ran after mjs-f',
'# mjs-h',
'ok 8 test ran after mjs-g',
'',
'1..8',
'# tests 8',
'# pass 8',
'',
'# ok'
].join('\n') + '\n\n');
};
var ps = tape('import/mjs-*.mjs');
ps.stdout.pipe(concat(tc));
ps.stderr.pipe(process.stderr);
ps.on('exit', function (code) {
t.equal(code, 0);
t.end();
});
} else {
t.pass('does not support dynamic import');
t.end();
}
});
});
tap.test('importing type: "module" files', function (t) {
hasDynamicImport().then(function (hasSupport) {
if (hasSupport) {
var tc = function (rows) {
t.same(rows.toString('utf8'), [
'TAP version 13',
'# package-type-a',
'ok 1 test ran',
'# package-type-b',
'ok 2 test ran after package-type-a',
'# package-type-c',
'ok 3 test ran after package-type-b',
'',
'1..3',
'# tests 3',
'# pass 3',
'',
'# ok'
].join('\n') + '\n\n');
};
var ps = tape('import/package_type/*.js');
ps.stdout.pipe(concat(tc));
ps.stderr.pipe(process.stderr);
ps.on('exit', function (code) {
t.equal(code, 0);
t.end();
});
} else {
t.pass('does not support dynamic import');
t.end();
}
});
});
tap.test('errors importing test files', function (t) {
hasDynamicImport().then(function (hasSupport) {
var createTest = function (options) {
var message = options.error + ' in `' + options.mode + '` mode`';
var ps = tape(options.files, { env: { NODE_OPTIONS: '--unhandled-rejections=' + options.mode } });
ps.stderr.pipe(concat(options.unhandledRejection(message)));
ps.on('exit', function (code/* , sig */) {
t.equal(code, options.exitCode, message + ' has exit code ' + options.exitCode);
});
};
var warning = function (message) {
return function (rows) {
t.match(rows.toString('utf8'), 'UnhandledPromiseRejectionWarning', 'should have unhandled rejection warning: ' + message);
};
};
var noWarning = function (message) {
return function (rows) {
t.notMatch(rows.toString('utf8'), 'UnhandledPromiseRejectionWarning', 'should not have unhandled rejection warning: ' + message);
};
};
if (hasSupport) {
var tests = [{
files: 'import/syntax-error.mjs import/mjs-a.mjs import/mjs-b.mjs',
error: 'syntax errors in first imported esm file',
mode: 'warn',
exitCode: 0,
unhandledRejection: warning
}, {
files: 'import/throws.mjs import/mjs-a.mjs import/mjs-b.mjs',
error: 'thrown errors in first imported esm file',
mode: 'warn',
exitCode: 0,
unhandledRejection: warning
}, {
files: 'import/mjs-a.mjs import/syntax-error.mjs',
error: 'syntax error in esm file',
mode: 'warn',
exitCode: 1,
unhandledRejection: warning
}, {
files: 'import/syntax-error.mjs',
error: 'syntax error in esm file',
mode: 'strict',
exitCode: 1,
unhandledRejection: noWarning
}, {
files: 'import/throws.mjs',
error: 'thrown error in esm file',
mode: 'strict',
exitCode: 1,
unhandledRejection: noWarning
}, {
files: 'import/syntax-error.cjs',
error: 'syntax error in cjs file',
mode: 'warn',
exitCode: 1,
unhandledRejection: noWarning
}, {
files: 'import/throws.cjs',
error: 'thrown error in cjs file',
mode: 'warn',
exitCode: 1,
unhandledRejection: noWarning
}, {
files: 'import/syntax-error.cjs',
error: 'syntax error in cjs file',
mode: 'strict',
exitCode: 1,
unhandledRejection: noWarning
}, {
files: 'import/throws.cjs',
error: 'thrown error in cjs file',
mode: 'strict',
exitCode: 1,
unhandledRejection: noWarning
}, {
files: 'import/mjs-a.mjs import/syntax-error.cjs',
error: 'syntax error in cjs file in loading promise',
mode: 'warn',
exitCode: 1,
unhandledRejection: warning
}, {
files: 'import/mjs-a.mjs import/syntax-error.cjs',
error: 'syntax error in cjs file in loading promise',
mode: 'strict',
exitCode: 1,
unhandledRejection: noWarning
}];
t.plan(tests.length * 2);
tests.map(createTest);
} else {
t.pass('does not support dynamic import');
t.end();
}
});
});
function tape(args, options) {
var bin = __dirname + '/../bin/tape';
return spawn('node', [bin].concat(args.split(' ')), assign({ cwd: __dirname }, options));
}
tape-5.5.2/test/import/ 0000775 0000000 0000000 00000000000 14202055663 0014750 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/import/mjs-a.mjs 0000664 0000000 0000000 00000000211 14202055663 0016464 0 ustar 00root root 0000000 0000000 import tape from '../../index.js';
tape.test('mjs-a', function (t) {
t.pass('test ran');
t.end();
global.mjs_a = true;
});
tape-5.5.2/test/import/mjs-b.mjs 0000664 0000000 0000000 00000000240 14202055663 0016467 0 ustar 00root root 0000000 0000000 import tape from '../../index.js';
tape.test('mjs-b', function (t) {
t.ok(global.mjs_a, 'test ran after mjs-a');
t.end();
global.mjs_b = true;
});
tape-5.5.2/test/import/mjs-c.mjs 0000664 0000000 0000000 00000000240 14202055663 0016470 0 ustar 00root root 0000000 0000000 import tape from '../../index.js';
tape.test('mjs-c', function (t) {
t.ok(global.mjs_b, 'test ran after mjs-b');
t.end();
global.mjs_c = true;
});
tape-5.5.2/test/import/mjs-d.mjs 0000664 0000000 0000000 00000000240 14202055663 0016471 0 ustar 00root root 0000000 0000000 import tape from '../../index.js';
tape.test('mjs-d', function (t) {
t.ok(global.mjs_c, 'test ran after mjs-c');
t.end();
global.mjs_d = true;
});
tape-5.5.2/test/import/mjs-e.mjs 0000664 0000000 0000000 00000000240 14202055663 0016472 0 ustar 00root root 0000000 0000000 import tape from '../../index.js';
tape.test('mjs-e', function (t) {
t.ok(global.mjs_d, 'test ran after mjs-d');
t.end();
global.mjs_e = true;
});
tape-5.5.2/test/import/mjs-f.mjs 0000664 0000000 0000000 00000000240 14202055663 0016473 0 ustar 00root root 0000000 0000000 import tape from '../../index.js';
tape.test('mjs-f', function (t) {
t.ok(global.mjs_e, 'test ran after mjs-e');
t.end();
global.mjs_f = true;
});
tape-5.5.2/test/import/mjs-g.mjs 0000664 0000000 0000000 00000000240 14202055663 0016474 0 ustar 00root root 0000000 0000000 import tape from '../../index.js';
tape.test('mjs-g', function (t) {
t.ok(global.mjs_f, 'test ran after mjs-f');
t.end();
global.mjs_g = true;
});
tape-5.5.2/test/import/mjs-h.mjs 0000664 0000000 0000000 00000000207 14202055663 0016500 0 ustar 00root root 0000000 0000000 import tape from '../../index.js';
tape.test('mjs-h', function (t) {
t.ok(global.mjs_g, 'test ran after mjs-g');
t.end();
});
tape-5.5.2/test/import/package_type/ 0000775 0000000 0000000 00000000000 14202055663 0017404 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/import/package_type/package-a.js 0000664 0000000 0000000 00000000236 14202055663 0021554 0 ustar 00root root 0000000 0000000 import tape from '../../../index.js';
tape.test('package-type-a', function (t) {
t.pass('test ran');
t.end();
global.package_type_a = true;
});
tape-5.5.2/test/import/package_type/package-b.js 0000664 0000000 0000000 00000000307 14202055663 0021554 0 ustar 00root root 0000000 0000000 import tape from '../../../index.js';
tape.test('package-type-b', function (t) {
t.ok(global.package_type_a, 'test ran after package-type-a');
t.end();
global.package_type_b = true;
});
tape-5.5.2/test/import/package_type/package-c.js 0000664 0000000 0000000 00000000245 14202055663 0021556 0 ustar 00root root 0000000 0000000 import tape from '../../../index.js';
tape.test('package-type-c', function (t) {
t.ok(global.package_type_b, 'test ran after package-type-b');
t.end();
});
tape-5.5.2/test/import/package_type/package.json 0000664 0000000 0000000 00000000031 14202055663 0021664 0 ustar 00root root 0000000 0000000 {
"type": "module"
}
tape-5.5.2/test/import/syntax-error.cjs 0000664 0000000 0000000 00000000003 14202055663 0020117 0 ustar 00root root 0000000 0000000 ))
tape-5.5.2/test/import/syntax-error.mjs 0000664 0000000 0000000 00000000003 14202055663 0020131 0 ustar 00root root 0000000 0000000 ))
tape-5.5.2/test/import/throws.cjs 0000664 0000000 0000000 00000000052 14202055663 0016774 0 ustar 00root root 0000000 0000000 'use strict';
throw new Error('thrown');
tape-5.5.2/test/import/throws.mjs 0000664 0000000 0000000 00000000033 14202055663 0017005 0 ustar 00root root 0000000 0000000 throw new Error('thrown');
tape-5.5.2/test/many.js 0000664 0000000 0000000 00000000317 14202055663 0014741 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/match.js 0000664 0000000 0000000 00000025472 14202055663 0015102 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('match', function (tt) {
tt.plan(1);
var test = tape.createHarness({ exit: false });
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# match',
'not ok 1 The "regexp" argument must be an instance of RegExp. Received type string (\'string\')',
' ---',
' operator: match',
' expected: \'[object RegExp]\'',
' actual: \'[object String]\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: The "regexp" argument must be an instance of RegExp. Received type string (\'string\')',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 2 regex arg must not be a string',
' ---',
' operator: match',
' expected: \'[object RegExp]\'',
' actual: \'[object String]\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: regex arg must not be a string',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 3 The "string" argument must be of type string. Received type object ({ abc: 123 })',
' ---',
' operator: match',
' expected: \'string\'',
' actual: \'object\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: The "string" argument must be of type string. Received type object ({ abc: 123 })',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 4 string arg must not be an object',
' ---',
' operator: match',
' expected: \'string\'',
' actual: \'object\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: string arg must not be an object',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 5 The input did not match the regular expression /abc/. Input: \'string\'',
' ---',
' operator: match',
' expected: /abc/',
' actual: \'string\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: The input did not match the regular expression /abc/. Input: \'string\'',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 6 "string" does not match /abc/',
' ---',
' operator: match',
' expected: /abc/',
' actual: \'string\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: "string" does not match /abc/',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 7 The input matched the regular expression /pass$/. Input: \'I will pass\'',
'ok 8 "I will pass" matches /pass$/',
'',
'1..8',
'# tests 8',
'# pass 2',
'# fail 6',
''
]);
};
test.createStream().pipe(concat(tc));
test('match', function (t) {
t.plan(8);
t.match(/abc/, 'string');
t.match(/abc/, 'string', 'regex arg must not be a string');
t.match({ abc: 123 }, /abc/);
t.match({ abc: 123 }, /abc/, 'string arg must not be an object');
t.match('string', /abc/);
t.match('string', /abc/, '"string" does not match /abc/');
t.match('I will pass', /pass$/);
t.match('I will pass', /pass$/, '"I will pass" matches /pass$/');
t.end();
});
});
tap.test('doesNotMatch', function (tt) {
tt.plan(1);
var test = tape.createHarness({ exit: false });
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# doesNotMatch',
'not ok 1 The "regexp" argument must be an instance of RegExp. Received type string (\'string\')',
' ---',
' operator: doesNotMatch',
' expected: \'[object RegExp]\'',
' actual: \'[object String]\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: The "regexp" argument must be an instance of RegExp. Received type string (\'string\')',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 2 regex arg must not be a string',
' ---',
' operator: doesNotMatch',
' expected: \'[object RegExp]\'',
' actual: \'[object String]\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: regex arg must not be a string',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 3 The "string" argument must be of type string. Received type object ({ abc: 123 })',
' ---',
' operator: doesNotMatch',
' expected: \'string\'',
' actual: \'object\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: The "string" argument must be of type string. Received type object ({ abc: 123 })',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 4 string arg must not be an object',
' ---',
' operator: doesNotMatch',
' expected: \'string\'',
' actual: \'object\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: string arg must not be an object',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 5 The input was expected to not match the regular expression /string/. Input: \'string\'',
' ---',
' operator: doesNotMatch',
' expected: /string/',
' actual: \'string\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: The input was expected to not match the regular expression /string/. Input: \'string\'',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 6 "string" should not match /string/',
' ---',
' operator: doesNotMatch',
' expected: /string/',
' actual: \'string\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: "string" should not match /string/',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 7 The input was expected to not match the regular expression /pass$/. Input: \'I will pass\'',
' ---',
' operator: doesNotMatch',
' expected: /pass$/',
' actual: \'I will pass\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: The input was expected to not match the regular expression /pass$/. Input: \'I will pass\'',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 8 "I will pass" should not match /pass$/',
' ---',
' operator: doesNotMatch',
' expected: /pass$/',
' actual: \'I will pass\'',
' at: Test. ($TEST/match.js:$LINE:$COL)',
' stack: |-',
' Error: "I will pass" should not match /pass$/',
' [... stack stripped ...]',
' at Test. ($TEST/match.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 9 The input did not match the regular expression /pass$/. Input: \'I will fail\'',
'ok 10 "I will fail" does not match /pass$/',
'',
'1..10',
'# tests 10',
'# pass 2',
'# fail 8',
''
]);
};
test.createStream().pipe(concat(tc));
test('doesNotMatch', function (t) {
t.plan(10);
t.doesNotMatch(/abc/, 'string');
t.doesNotMatch(/abc/, 'string', 'regex arg must not be a string');
t.doesNotMatch({ abc: 123 }, /abc/);
t.doesNotMatch({ abc: 123 }, /abc/, 'string arg must not be an object');
t.doesNotMatch('string', /string/);
t.doesNotMatch('string', /string/, '"string" should not match /string/');
t.doesNotMatch('I will pass', /pass$/);
t.doesNotMatch('I will pass', /pass$/, '"I will pass" should not match /pass$/');
t.doesNotMatch('I will fail', /pass$/);
t.doesNotMatch('I will fail', /pass$/, '"I will fail" does not match /pass$/');
t.end();
});
});
tape-5.5.2/test/max_listeners.js 0000664 0000000 0000000 00000000456 14202055663 0016656 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/max_listeners/ 0000775 0000000 0000000 00000000000 14202055663 0016313 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/max_listeners/source.js 0000664 0000000 0000000 00000000246 14202055663 0020153 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
for (var i = 0; i < 11; i++) {
test(function (t) {
t.ok(true, 'true is truthy');
t.end();
});
}
tape-5.5.2/test/messages/ 0000775 0000000 0000000 00000000000 14202055663 0015245 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/messages/defaults.js 0000664 0000000 0000000 00000000721 14202055663 0017412 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
test('default messages', function (t) {
t.plan(12);
t.ok(true);
t.notOk(false);
t.equal(true, true);
t.notEqual(true, false);
t.looseEqual(true, true);
t.notLooseEqual(true, false);
t.strictEqual(true, true);
t.notStrictEqual(true, false);
t.deepEqual(true, true);
t.notDeepEqual(true, true);
t.deepLooseEqual(true, true);
t.notDeepLooseEqual(true, false);
});
tape-5.5.2/test/nested-async-plan-noend.js 0000664 0000000 0000000 00000001630 14202055663 0020422 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/nested-sync-noplan-noend.js 0000664 0000000 0000000 00000002123 14202055663 0020614 0 ustar 00root root 0000000 0000000 'use strict';
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').split('\n'), [
'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',
''
]);
};
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-5.5.2/test/nested.js 0000664 0000000 0000000 00000004123 14202055663 0015256 0 ustar 00root root 0000000 0000000 'use strict';
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').split('\n'), [
'TAP version 13',
'# nested array test',
'ok 1 should be deeply equivalent',
'ok 2 should be deeply equivalent',
'ok 3 should be deeply equivalent',
'ok 4 should be deeply equivalent',
'ok 5 should be deeply 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',
''
]);
};
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-5.5.2/test/nested2.js 0000664 0000000 0000000 00000000523 14202055663 0015340 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
test(function (t) {
var i = 0;
t.test('setup', function (st) {
process.nextTick(function () {
st.equal(i, 0, 'called once');
i++;
st.end();
});
});
t.test('teardown', function (st) {
st.end();
});
t.end();
});
tape-5.5.2/test/no_callback.js 0000664 0000000 0000000 00000002244 14202055663 0016226 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('no callback', function (tt) {
tt.plan(1);
var test = tape.createHarness();
var tc = function (rows) {
var body = stripFullStack(rows.toString('utf8'));
tt.same(body, [
'TAP version 13',
'# group',
'# No callback.',
'not ok 1 # TODO No callback.',
' ---',
' operator: fail',
' stack: |-',
' Error: # TODO No callback.',
' [... stack stripped ...]',
' ...',
'# SKIP No callback, skipped.',
'# TODO No callback, todo.',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
};
test.createStream().pipe(concat(tc));
test('group', function (t) {
t.plan(3);
t.test('No callback.');
t.test('No callback, skipped.', { skip: true });
t.test('No callback, todo.', { todo: true });
});
});
tape-5.5.2/test/no_only.js 0000664 0000000 0000000 00000007440 14202055663 0015456 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var path = require('path');
var exec = require('child_process').exec;
var stripFullStack = require('./common').stripFullStack;
var tapeBin = path.join(__dirname, '../bin/tape');
var expectedExitCodeFailure = (/^0\.10\.\d+$/).test(process.versions.node);
var expectedStackTraceBug = (/^3\.[012]\.\d+$/).test(process.versions.node); // https://github.com/nodejs/node/issues/2581
tap.test(
'Should throw error when --no-only is passed via cli and there is a .only test',
{ todo: expectedExitCodeFailure || expectedStackTraceBug ? 'Fails on these node versions' : false },
function (tt) {
tt.plan(3);
exec(tapeBin + ' --no-only "**/*.js"', {
cwd: path.join(__dirname, 'no_only')
}, function (err, stdout, stderr) {
tt.same(stdout.toString('utf8'), '');
tt.match(stripFullStack(stderr.toString('utf8')).join('\n'), /Error: `only` tests are prohibited\n/);
tt.equal(err.code, 1);
});
}
);
tap.test(
'Should throw error when NODE_TAPE_NO_ONLY_TEST is passed via envs and there is an .only test',
{ todo: expectedExitCodeFailure || expectedStackTraceBug ? 'Fails on these node versions' : false },
function (tt) {
tt.plan(3);
exec(tapeBin + ' "**/*.js"', {
cwd: path.join(__dirname, 'no_only'),
env: { PATH: process.env.PATH, NODE_TAPE_NO_ONLY_TEST: 'true' }
}, function (err, stdout, stderr) {
tt.same(stdout.toString('utf8'), '');
tt.match(stripFullStack(stderr.toString('utf8')).join('\n'), /Error: `only` tests are prohibited\n/);
tt.equal(err.code, 1);
});
}
);
tap.test(
'Should override NODE_TAPE_NO_ONLY_TEST env if --no-only is passed from cli',
{ todo: expectedExitCodeFailure || expectedStackTraceBug ? 'Fails on these node versions' : false },
function (tt) {
tt.plan(3);
exec(tapeBin + ' --no-only "**/*.js"', {
cwd: path.join(__dirname, 'no_only'),
env: { PATH: process.env.PATH, NODE_TAPE_NO_ONLY_TEST: 'false' }
}, function (err, stdout, stderr) {
tt.same(stdout.toString('utf8'), '');
tt.match(stripFullStack(stderr.toString('utf8')).join('\n'), /Error: `only` tests are prohibited\n/);
tt.equal(err.code, 1);
});
}
);
tap.test('Should run successfully if there is no only test', function (tt) {
tt.plan(3);
exec(tapeBin + ' --no-only "**/test-a.js"', {
cwd: path.join(__dirname, 'no_only')
}, function (err, stdout, stderr) {
tt.match(stderr.toString('utf8'), /^\s*(\(node:\d+\) ExperimentalWarning: The ESM module loader is experimental\.)?\s*$/);
tt.same(stripFullStack(stdout.toString('utf8')), [
'TAP version 13',
'# should pass',
'ok 1 should be truthy',
'',
'1..1',
'# tests 1',
'# pass 1',
'',
'# ok',
'',
''
]);
tt.equal(err, null); // code 0
});
});
tap.test('Should run successfully if there is an only test and no --no-only flag', function (tt) {
tt.plan(3);
exec(tapeBin + ' "**/test-b.js"', {
cwd: path.join(__dirname, 'no_only')
}, function (err, stdout, stderr) {
tt.same(stripFullStack(stdout.toString('utf8')), [
'TAP version 13',
'# should pass again',
'ok 1 should be truthy',
'',
'1..1',
'# tests 1',
'# pass 1',
'',
'# ok',
'',
''
]);
tt.match(stderr.toString('utf8'), /^\s*(\(node:\d+\) ExperimentalWarning: The ESM module loader is experimental\.)?\s*$/);
tt.equal(err, null); // code 0
});
});
tape-5.5.2/test/no_only/ 0000775 0000000 0000000 00000000000 14202055663 0015113 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/no_only/test-a.js 0000664 0000000 0000000 00000000166 14202055663 0016651 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../');
tape.test('should pass', function (t) {
t.plan(1);
t.ok(1);
});
tape-5.5.2/test/no_only/test-b.js 0000664 0000000 0000000 00000000313 14202055663 0016644 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../../');
tape.test('should pass', function (t) {
t.plan(1);
t.ok(1);
});
tape.test.only('should pass again', function (t) {
t.plan(1);
t.ok(1);
});
tape-5.5.2/test/not-deep-equal-failure.js 0000664 0000000 0000000 00000015037 14202055663 0020247 0 ustar 00root root 0000000 0000000 'use strict';
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.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# not deep equal',
'not ok 1 should not be deeply equivalent',
' ---',
' operator: notDeepEqual',
' expected: |-',
' { b: 2 }',
' actual: |-',
' { b: 2 }',
' at: Test. ($TEST/not-deep-equal-failure.js:$LINE:$COL)',
' stack: |-',
' Error: should not be deeply equivalent',
' [... stack stripped ...]',
' at Test. ($TEST/not-deep-equal-failure.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
assert.deepEqual(getDiag(body), {
operator: 'notDeepEqual',
expected: '{ b: 2 }',
actual: '{ b: 2 }'
});
}));
parser.once('assert', function (data) {
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should not be deeply equivalent',
diag: {
operator: 'notDeepEqual',
expected: '{ b: 2 }',
actual: '{ b: 2 }',
// we don't care about these next two
stack: data.diag.stack,
at: data.diag.at
}
});
});
test('not deep equal', function (t) {
t.plan(1);
t.notDeepEqual({ b: 2 }, { b: 2 });
});
});
tap.test('not 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.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# not deep equal',
'not ok 1 should not be deeply equivalent',
' ---',
' operator: notDeepEqual',
' expected: |-',
' { a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
' actual: |-',
' { a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
' at: Test. ($TEST/not-deep-equal-failure.js:$LINE:$COL)',
' stack: |-',
' Error: should not be deeply equivalent',
' [... stack stripped ...]',
' at Test. ($TEST/not-deep-equal-failure.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
assert.deepEqual(getDiag(body), {
operator: 'notDeepEqual',
expected: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }'
});
}));
parser.once('assert', function (data) {
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should not be deeply equivalent',
diag: {
operator: 'notDeepEqual',
expected: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
// we don't care about these next two
stack: data.diag.stack,
at: data.diag.at
}
});
});
test('not deep equal', { objectPrintDepth: 6 }, function (t) {
t.plan(1);
t.notDeepEqual({ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }, { a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } });
});
});
tap.test('not 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.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# not deep equal',
'not ok 1 should not be deeply equivalent',
' ---',
' operator: notDeepEqual',
' expected: |-',
' { a: { a1: { a2: { a3: { a4: [Object] } } } } }',
' actual: |-',
' { a: { a1: { a2: { a3: { a4: [Object] } } } } }',
' at: Test. ($TEST/not-deep-equal-failure.js:$LINE:$COL)',
' stack: |-',
' Error: should not be deeply equivalent',
' [... stack stripped ...]',
' at Test. ($TEST/not-deep-equal-failure.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
assert.deepEqual(getDiag(body), {
operator: 'notDeepEqual',
expected: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }'
});
}));
parser.once('assert', function (data) {
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should not be deeply equivalent',
diag: {
operator: 'notDeepEqual',
expected: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
actual: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
// we don't care about these next two
stack: data.diag.stack,
at: data.diag.at
}
});
});
test('not deep equal', function (t) {
t.plan(1);
t.notDeepEqual({ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }, { a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } });
});
});
tape-5.5.2/test/not-equal-failure.js 0000664 0000000 0000000 00000003735 14202055663 0017336 0 ustar 00root root 0000000 0000000 'use strict';
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('not 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.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# not equal',
'not ok 1 should not be strictly equal',
' ---',
' operator: notEqual',
' expected: 2',
' actual: 2',
' at: Test. ($TEST/not-equal-failure.js:$LINE:$COL)',
' stack: |-',
' Error: should not be strictly equal',
' [... stack stripped ...]',
' at Test. ($TEST/not-equal-failure.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
assert.deepEqual(getDiag(body), {
operator: 'notEqual',
expected: '2',
actual: '2'
});
}));
parser.once('assert', function (data) {
assert.deepEqual(data, {
ok: false,
id: 1,
name: 'should not be strictly equal',
diag: {
operator: 'notEqual',
expected: '2',
actual: '2',
// we don't care about these next two
stack: data.diag.stack,
at: data.diag.at
}
});
});
test('not equal', function (t) {
t.plan(1);
t.notEqual(2, 2);
});
});
tape-5.5.2/test/numerics.js 0000664 0000000 0000000 00000017141 14202055663 0015625 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('numerics', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream().pipe(concat(function (body) {
tt.same(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# numeric strings',
'not ok 1 number equal to string',
' ---',
' operator: equal',
' expected: \'3\'',
' actual: 3',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: number equal to string',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 2 string equal to number',
' ---',
' operator: equal',
' expected: 3',
' actual: \'3\'',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: string equal to number',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 3 number notEqual to string',
'ok 4 string notEqual to number',
'ok 5 number looseEqual to string',
'ok 6 string looseEqual to number',
'not ok 7 number notLooseEqual to string',
' ---',
' operator: notLooseEqual',
' expected: \'3\'',
' actual: 3',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: number notLooseEqual to string',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 8 string notLooseEqual to number',
' ---',
' operator: notLooseEqual',
' expected: 3',
' actual: \'3\'',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: string notLooseEqual to number',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 9 number strictEqual to string',
' ---',
' operator: equal',
' expected: \'3\'',
' actual: 3',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: number strictEqual to string',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 10 string strictEqual to number',
' ---',
' operator: equal',
' expected: 3',
' actual: \'3\'',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: string strictEqual to number',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 11 number notStrictEqual to string',
'ok 12 string notStrictEqual to number',
'ok 13 number deepLooseEqual to string',
'ok 14 string deepLooseEqual to number',
'not ok 15 number notDeepLooseEqual to string',
' ---',
' operator: notDeepLooseEqual',
' expected: \'3\'',
' actual: 3',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: number notDeepLooseEqual to string',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 16 string notDeepLooseEqual to number',
' ---',
' operator: notDeepLooseEqual',
' expected: 3',
' actual: \'3\'',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: string notDeepLooseEqual to number',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 17 number deepEqual to string',
' ---',
' operator: deepEqual',
' expected: \'3\'',
' actual: 3',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: number deepEqual to string',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'not ok 18 string deepEqual to number',
' ---',
' operator: deepEqual',
' expected: 3',
' actual: \'3\'',
' at: Test. ($TEST/numerics.js:$LINE:$COL)',
' stack: |-',
' Error: string deepEqual to number',
' [... stack stripped ...]',
' at Test. ($TEST/numerics.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'ok 19 number notDeepEqual to string',
'ok 20 string notDeepEqual to number',
'',
'1..20',
'# tests 20',
'# pass 10',
'# fail 10',
''
]);
}));
test('numeric strings', function (t) {
t.equal(3, '3', 'number equal to string');
t.equal('3', 3, 'string equal to number');
t.notEqual(3, '3', 'number notEqual to string');
t.notEqual('3', 3, 'string notEqual to number');
t.looseEqual(3, '3', 'number looseEqual to string');
t.looseEqual('3', 3, 'string looseEqual to number');
t.notLooseEqual(3, '3', 'number notLooseEqual to string');
t.notLooseEqual('3', 3, 'string notLooseEqual to number');
t.strictEqual(3, '3', 'number strictEqual to string');
t.strictEqual('3', 3, 'string strictEqual to number');
t.notStrictEqual(3, '3', 'number notStrictEqual to string');
t.notStrictEqual('3', 3, 'string notStrictEqual to number');
t.deepLooseEqual(3, '3', 'number deepLooseEqual to string');
t.deepLooseEqual('3', 3, 'string deepLooseEqual to number');
t.notDeepLooseEqual(3, '3', 'number notDeepLooseEqual to string');
t.notDeepLooseEqual('3', 3, 'string notDeepLooseEqual to number');
t.deepEqual(3, '3', 'number deepEqual to string');
t.deepEqual('3', 3, 'string deepEqual to number');
t.notDeepEqual(3, '3', 'number notDeepEqual to string');
t.notDeepEqual('3', 3, 'string notDeepEqual to number');
t.end();
});
});
tape-5.5.2/test/objectMode.js 0000664 0000000 0000000 00000003600 14202055663 0016046 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var tape = require('../');
var forEach = require('for-each');
var through = require('through');
tap.test('object results', function (assert) {
var printer = through({ objectMode: true });
var objects = [];
printer.write = function (obj) {
objects.push(obj);
};
printer.end = function (obj) {
if (obj) { objects.push(obj); }
var todos = 0;
var skips = 0;
var testIds = [];
var endIds = [];
var asserts = 0;
assert.equal(objects.length, 13);
forEach(objects, function (object) {
if (object.type === 'assert') {
asserts++;
} else if (object.type === 'test') {
testIds.push(object.id);
if (object.skip) {
skips++;
} else if (object.todo) {
todos++;
}
} else if (object.type === 'end') {
endIds.push(object.text);
// test object should exist
assert.notEqual(testIds.indexOf(object.test), -1);
}
});
assert.equal(asserts, 5);
assert.equal(skips, 1);
assert.equal(todos, 2);
assert.equal(testIds.length, endIds.length);
assert.end();
};
tape.createStream({ objectMode: true }).pipe(printer);
tape('parent', function (t1) {
t1.equal(true, true);
t1.test('child1', { skip: true }, function (t2) {
t2.equal(true, true);
t2.equal(true, false);
t2.end();
});
t1.test('child2', { todo: true }, function (t3) {
t3.equal(true, false);
t3.equal(true, true);
t3.end();
});
t1.test('child3', { todo: true });
t1.equal(true, true);
t1.equal(true, true);
t1.end();
});
});
tape-5.5.2/test/objectModeWithComment.js 0000664 0000000 0000000 00000001722 14202055663 0020230 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var tape = require('../');
var through = require('through');
tap.test('test.comment() in objectMode', function (assert) {
var printer = through({ objectMode: true });
var objects = [];
printer.on('error', function (e) {
assert.fail(e);
});
printer.write = function (obj) {
objects.push(obj);
};
printer.end = function (obj) {
if (obj) { objects.push(obj); }
assert.equal(objects.length, 3);
assert.deepEqual(objects, [
{
type: 'test',
name: 'test.comment',
id: 0,
skip: false,
todo: false
},
'message',
{ type: 'end', test: 0 }
]);
assert.end();
};
tape.createStream({ objectMode: true }).pipe(printer);
tape('test.comment', function (test) {
test.comment('message');
test.end();
});
});
tape-5.5.2/test/onFailure.js 0000664 0000000 0000000 00000001077 14202055663 0015725 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/onFinish.js 0000664 0000000 0000000 00000000430 14202055663 0015546 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/only-twice.js 0000664 0000000 0000000 00000000722 14202055663 0016067 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/only.js 0000664 0000000 0000000 00000001776 14202055663 0014770 0 ustar 00root root 0000000 0000000 'use strict';
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').split('\n'), [
'TAP version 13',
'# run success',
'ok 1 assert name',
'',
'1..1',
'# tests 1',
'# pass 1',
'',
'# ok',
''
]);
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-5.5.2/test/only2.js 0000664 0000000 0000000 00000000233 14202055663 0015035 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
test('only2 test 1', function (t) {
t.end();
});
test.only('only2 test 2', function (t) {
t.end();
});
tape-5.5.2/test/only3.js 0000664 0000000 0000000 00000000373 14202055663 0015043 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/only4.js 0000664 0000000 0000000 00000000312 14202055663 0015035 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/only5.js 0000664 0000000 0000000 00000000312 14202055663 0015036 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/order.js 0000664 0000000 0000000 00000000454 14202055663 0015112 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/plan_optional.js 0000664 0000000 0000000 00000000453 14202055663 0016635 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/promise_fail.js 0000664 0000000 0000000 00000007677 14202055663 0016466 0 ustar 00root root 0000000 0000000 'use strict';
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('callback returning rejected promise should cause that test (and only that test) to fail', function (tt) {
tt.plan(1);
var ps = spawn(process.execPath, [path.join(__dirname, 'promises', 'fail.js')]);
ps.stdout.pipe(concat(function (rows) {
var rowsString = rows.toString('utf8');
if ((/^skip\n$/).test(rowsString)) {
tt.pass('the test file indicated it should be skipped');
return;
}
var strippedString = stripFullStack(rowsString).filter(function (line) {
return !(/^(\s+)at(\s+)(?:Test\.)?(?:$|\s)/).test(line);
}).join('\n');
// hack for consistency across all versions of node
// some versions produce a longer stack trace for some reason
// since this doesn't affect the validity of the test, the extra line is removed if present
// the regex just removes the lines "at " and "[... stack stripped ...]" if they occur together
strippedString = strippedString
.replace(/.+at (?:Test\.)?\n.+\[\.\.\. stack stripped \.\.\.\]\n/g, '')
.replace(/(?:(.+)\[\.\.\. stack stripped \.\.\.\]\n)+/g, '$1[... stack stripped ...]\n');
tt.same(strippedString, [
'TAP version 13',
'# promise',
'not ok 1 Error: rejection message',
' ---',
' operator: error',
' stack: |-',
' Error: rejection message',
' at $TEST/promises/fail.js:$LINE:$COL',
' [... stack stripped ...]',
' ...',
'# after',
'ok 2 should be truthy',
'',
'1..2',
'# tests 2',
'# pass 1',
'# fail 1',
'',
''
].join('\n'));
}));
});
tap.test('subtest callback returning rejected promise should cause that subtest (and only that subtest) to fail', function (tt) {
tt.plan(1);
var ps = spawn(process.execPath, [path.join(__dirname, 'promises', 'subTests.js')]);
ps.stdout.pipe(concat(function (rows) {
var rowsString = rows.toString('utf8');
if ((/^skip\n$/).test(rowsString)) {
tt.pass('the test file indicated it should be skipped');
return;
}
var strippedString = stripFullStack(rowsString).filter(function (line) {
return !(/^(\s+)at(\s+)(?:Test\.)?(?:$|\s)/).test(line);
}).join('\n');
// hack for consistency across all versions of node
// some versions produce a longer stack trace for some reason
// since this doesn't affect the validity of the test, the extra line is removed if present
// the regex just removes the lines "at " and "[... stack stripped ...]" if they occur together
strippedString = strippedString
.replace(/.+at (?:Test\.)?\n.+\[\.\.\. stack stripped \.\.\.\]\n/, '')
.replace(/(?:(.+)\[\.\.\. stack stripped \.\.\.\]\n)+/g, '$1[... stack stripped ...]\n');
tt.same(stripFullStack(strippedString), [
'TAP version 13',
'# promise',
'# sub test that should fail',
'not ok 1 Error: rejection message',
' ---',
' operator: error',
' stack: |-',
' Error: rejection message',
' at $TEST/promises/subTests.js:$LINE:$COL',
' [... stack stripped ...]',
' ...',
'# sub test that should pass',
'ok 2 should be truthy',
'',
'1..2',
'# tests 2',
'# pass 1',
'# fail 1',
'',
''
]);
}));
});
tape-5.5.2/test/promises/ 0000775 0000000 0000000 00000000000 14202055663 0015277 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/promises/fail.js 0000664 0000000 0000000 00000000716 14202055663 0016554 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
if (typeof Promise === 'function' && typeof Promise.resolve === 'function') {
test('promise', function () {
return new Promise(function (resolve, reject) {
reject(new Error('rejection message'));
});
});
test('after', function (t) {
t.plan(1);
t.ok(true);
});
} else {
// if promises aren't supported pass the node-tap test
console.log('skip');
}
tape-5.5.2/test/promises/subTests.js 0000664 0000000 0000000 00000001111 14202055663 0017443 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../../');
if (typeof Promise === 'function' && typeof Promise.resolve === 'function') {
test('promise', function (t) {
t.test('sub test that should fail', function () {
return new Promise(function (resolve, reject) {
reject(new Error('rejection message'));
});
});
t.test('sub test that should pass', function (st) {
st.plan(1);
st.ok(true);
});
});
} else {
// if promises aren't supported pass the node-tap test
console.log('skip');
}
tape-5.5.2/test/require.js 0000664 0000000 0000000 00000003641 14202055663 0015454 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var spawn = require('child_process').spawn;
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('requiring a single module', function (t) {
t.plan(2);
var tc = function (rows) {
t.same(stripFullStack(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',
'',
''
]);
};
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 bin = __dirname + '/../bin/tape';
return spawn('node', [bin].concat(args.split(' ')), { cwd: __dirname });
}
tape-5.5.2/test/require/ 0000775 0000000 0000000 00000000000 14202055663 0015112 5 ustar 00root root 0000000 0000000 tape-5.5.2/test/require/a.js 0000664 0000000 0000000 00000000235 14202055663 0015670 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../..');
tape.test('module-a', function (t) {
t.plan(1);
t.pass('loaded module a');
});
global.module_a = true;
tape-5.5.2/test/require/b.js 0000664 0000000 0000000 00000000235 14202055663 0015671 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../..');
tape.test('module-b', function (t) {
t.plan(1);
t.pass('loaded module b');
});
global.module_b = true;
tape-5.5.2/test/require/test-a.js 0000664 0000000 0000000 00000000321 14202055663 0016641 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/require/test-b.js 0000664 0000000 0000000 00000000321 14202055663 0016642 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/skip.js 0000664 0000000 0000000 00000002111 14202055663 0014735 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
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');
t.end();
});
test.skip('skip this too', function (t) {
t.fail('this should not even run');
t.end();
});
test('skip subtest', function (t) {
t.test('skip this', { skip: true }, function (st) {
st.fail('this should not even run');
st.end();
});
t.end();
});
// vim: set softtabstop=4 shiftwidth=4:
tape-5.5.2/test/skip_explanation.js 0000664 0000000 0000000 00000005277 14202055663 0017357 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var test = require('../');
var concat = require('concat-stream');
var stripFullStack = require('./common').stripFullStack;
tap.test('test skip explanations', function (assert) {
assert.plan(1);
var verify = function (output) {
assert.deepEqual(stripFullStack(output.toString('utf8')), [
'TAP version 13',
'# SKIP (this skips)',
'# some tests might skip',
'ok 1 this runs',
'ok 2 failing assert is skipped # SKIP',
'ok 3 this runs',
'# incomplete test',
'ok 4 run sh',
'ok 5 run openssl # SKIP',
'# incomplete test with explanation',
'ok 6 run sh (conditional skip) # SKIP',
'ok 7 run openssl # SKIP can\'t run on windows platforms',
'ok 8 this runs',
'# too much explanation',
'ok 9 run openssl # SKIP Installer cannot work on windows and fails to add to PATH Err: (2401) denied',
'',
'1..9',
'# tests 9',
'# pass 9',
'',
'# ok',
''
]);
};
var tapeTest = test.createHarness();
tapeTest.createStream().pipe(concat(verify));
tapeTest('(this skips)', { skip: true }, function (t) {
t.fail('doesn\'t run');
t.fail('this doesn\'t run too', { skip: false });
t.end();
});
tapeTest('some tests might skip', function (t) {
t.pass('this runs');
t.fail('failing assert is skipped', { skip: true });
t.pass('this runs');
t.end();
});
tapeTest('incomplete test', function (t) {
// var platform = process.platform; something like this needed
var platform = 'win32';
t.pass('run sh', { skip: platform !== 'win32' });
t.pass('run openssl', { skip: platform === 'win32' });
t.end();
});
tapeTest('incomplete test with explanation', function (t) {
// var platform = process.platform; something like this needed
var platform = 'win32';
t.fail('run sh (conditional skip)', { skip: platform === 'win32' });
t.fail('run openssl', { skip: platform === 'win32' && 'can\'t run on windows platforms' });
t.pass('this runs');
t.end();
});
tapeTest('too much explanation', function (t) {
// var platform = process.platform; something like this needed
var platform = 'win32';
t.fail(
'run openssl',
{ skip: platform === 'win32' && 'Installer cannot work on windows\nand fails to add to PATH\n\n Err: (2401) denied' }
);
t.end();
});
});
// vim: set softtabstop=4 shiftwidth=4:
tape-5.5.2/test/stackTrace.js 0000664 0000000 0000000 00000021142 14202055663 0016060 0 ustar 00root root 0000000 0000000 'use strict';
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) {
tt.deepEqual(data, {
ok: false,
id: 1,
name: 'Error: Preserve stack',
diag: {
stack: stackTrace,
operator: 'error',
at: data.diag.at // we don't care about this one
}
});
});
stream.pipe(concat(function (body) {
var strippedBody = stripAt(body.toString('utf8'));
tt.deepEqual(strippedBody.split('\n'), [
'TAP version 13',
'# multiline stack trace',
'not ok 1 Error: Preserve stack',
' ---',
' operator: error',
' stack: |-',
' foo',
' bar',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
tt.deepEqual(getDiag(strippedBody), {
stack: stackTrace,
operator: 'error'
});
}));
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 info from original stack', function (tt) {
tt.plan(4);
var test = tape.createHarness();
test.createStream();
test._results._watch = function (t) {
t.on('result', function (res) {
tt.equal('Test.testFunctionNameParsing', res.functionName);
tt.match(res.file, /stackTrace.js/i);
tt.ok(Number(res.line) > 0);
tt.ok(Number(res.column) > 0);
});
};
test('t.equal stack trace', function testFunctionNameParsing(t) {
t.equal(true, false, 'true should be false');
t.end();
});
});
tap.test('parses function info from original stack for anonymous function', function (tt) {
tt.plan(4);
var test = tape.createHarness();
test.createStream();
test._results._watch = function (t) {
t.on('result', function (res) {
tt.equal('Test.', res.functionName);
tt.match(res.file, /stackTrace.js/i);
tt.ok(Number(res.line) > 0);
tt.ok(Number(res.column) > 0);
});
};
test('t.equal stack trace', function (t) {
t.equal(true, false, 'true should be false');
t.end();
});
});
if (typeof Promise === 'function' && typeof Promise.resolve === 'function') {
tap.test('parses function info from original stack for Promise scenario', function (tt) {
tt.plan(4);
var test = tape.createHarness();
test.createStream();
test._results._watch = function (t) {
t.on('result', function (res) {
tt.equal('onfulfilled', res.functionName);
tt.match(res.file, /stackTrace.js/i);
tt.ok(Number(res.line) > 0);
tt.ok(Number(res.column) > 0);
});
};
test('t.equal stack trace', function testFunctionNameParsing(t) {
new Promise(function (resolve) {
resolve();
}).then(function onfulfilled() {
t.equal(true, false, 'true should be false');
t.end();
});
});
});
tap.test('parses function info from original stack for Promise scenario with anonymous function', function (tt) {
tt.plan(4);
var test = tape.createHarness();
test.createStream();
test._results._watch = function (t) {
t.on('result', function (res) {
tt.equal('', res.functionName);
tt.match(res.file, /stackTrace.js/i);
tt.ok(Number(res.line) > 0);
tt.ok(Number(res.column) > 0);
});
};
test('t.equal stack trace', function testFunctionNameParsing(t) {
new Promise(function (resolve) {
resolve();
}).then(function () {
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');
var at = data.diag.at || '';
stack = data.diag.stack || '';
tt.ok((/^Error: true should be false(\n {4}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 strippedBody = stripAt(body.toString('utf8'));
tt.deepEqual(strippedBody.split('\n'), [].concat(
'TAP version 13',
'# t.equal stack trace',
'not ok 1 true should be false',
' ---',
' operator: equal',
' expected: false',
' actual: true',
' stack: |-',
stack.split('\n').map(function (x) { return ' ' + x; }),
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
));
tt.deepEqual(getDiag(strippedBody), {
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');
var at = data.diag.at || '';
stack = data.diag.stack || '';
tt.ok((/^Error: false should be true(\n {4}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 strippedBody = stripAt(body.toString('utf8'));
tt.deepEqual(strippedBody.split('\n'), [].concat(
'TAP version 13',
'# t.equal stack trace',
'not ok 1 false should be true',
' ---',
' operator: equal',
' expected: true',
' actual: false',
' stack: |-',
stack.split('\n').map(function (x) { return ' ' + x; }),
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
));
tt.deepEqual(getDiag(strippedBody), {
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-5.5.2/test/subcount.js 0000664 0000000 0000000 00000000452 14202055663 0015637 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
test('parent test', function (t) {
t.plan(2);
t.test('first child', function (st) {
st.plan(1);
st.pass('pass first child');
});
t.test(function (st) {
st.plan(1);
st.pass('pass second child');
});
});
tape-5.5.2/test/subtest_and_async.js 0000664 0000000 0000000 00000001157 14202055663 0017510 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
var asyncFunction = function (callback) {
setTimeout(callback, Math.random * 50);
};
test('master test', function (t) {
t.test('subtest 1', function (st) {
st.pass('subtest 1 before async call');
asyncFunction(function () {
st.pass('subtest 1 in async callback');
st.end();
});
});
t.test('subtest 2', function (st) {
st.pass('subtest 2 before async call');
asyncFunction(function () {
st.pass('subtest 2 in async callback');
st.end();
});
});
t.end();
});
tape-5.5.2/test/subtest_plan.js 0000664 0000000 0000000 00000000717 14202055663 0016504 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('../');
test('parent', function (t) {
t.plan(3);
var firstChildRan = false;
t.pass('assertion in parent');
t.test('first child', function (st) {
st.plan(1);
st.pass('pass first child');
firstChildRan = true;
});
t.test('second child', function (st) {
st.plan(2);
st.ok(firstChildRan, 'first child ran first');
st.pass('pass second child');
});
});
tape-5.5.2/test/teardown.js 0000664 0000000 0000000 00000024670 14202055663 0015630 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var forEach = require('for-each');
var v = require('es-value-fixtures');
var inspect = require('object-inspect');
var flatMap = require('array.prototype.flatmap');
var stripFullStack = require('./common').stripFullStack;
tap.test('teardowns', function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream().pipe(concat(function (body) {
tt.same(stripFullStack(body.toString('utf8')), [].concat(
'TAP version 13',
'# success',
'ok 1 should be truthy',
'# success teardown',
'# success teardown 2',
'# success (async)',
'ok 2 should be truthy',
'# success (async) teardown',
'# success (async) teardown 2',
'# nested teardowns',
'# nested success',
'ok 3 should be truthy',
'# nested teardown (nested success level)',
'# nested teardown (nested success level) 2',
'# nested failure',
'not ok 4 nested failure!',
' ---',
' operator: fail',
' at: Test. ($TEST/teardown.js:$LINE:$COL)',
' stack: |-',
' Error: nested failure!',
' [... stack stripped ...]',
' at Test. ($TEST/teardown.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'# nested teardown (nested fail level)',
'# nested teardown (nested fail level) 2',
'# nested teardown (top level)',
'# nested teardown (top level) 2',
'# fail',
'not ok 5 failure!',
' ---',
' operator: fail',
' at: Test. ($TEST/teardown.js:$LINE:$COL)',
' stack: |-',
' Error: failure!',
' [... stack stripped ...]',
' at Test. ($TEST/teardown.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'# failure teardown',
'# failure teardown 2',
'# teardown errors do not stop the next teardown fn from running',
'ok 6 should be truthy',
'not ok 7 SyntaxError: teardown error!',
' ---',
' operator: fail',
' stack: |-',
' Error: SyntaxError: teardown error!',
' [... stack stripped ...]',
' ...',
'not ok 8 plan != count',
' ---',
' operator: fail',
' expected: 1',
' actual: 2',
' stack: |-',
' Error: plan != count',
' [... stack stripped ...]',
' ...',
'# teardown runs after teardown error',
'# teardown given non-function fails the test',
'ok 9 should be truthy',
flatMap(v.nonFunctions, function (nonFunction, i) {
var offset = 10;
return [].concat(
'not ok ' + (offset + (i > 0 ? i + 1 : i)) + ' teardown: ' + inspect(nonFunction) + ' is not a function',
' ---',
' operator: fail',
' at: ($TEST/teardown.js:$LINE:$COL)',
' stack: |-',
' Error: teardown: ' + inspect(nonFunction) + ' is not a function',
' [... stack stripped ...]',
' at $TEST/teardown.js:$LINE:$COL',
' [... stack stripped ...]',
' at Test. ($TEST/teardown.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
i > 0 ? [] : [
'not ok ' + (offset + 1) + ' plan != count',
' ---',
' operator: fail',
' expected: 1',
' actual: 2',
' at: ($TEST/teardown.js:$LINE:$COL)',
' stack: |-',
' Error: plan != count',
' [... stack stripped ...]',
' at $TEST/teardown.js:$LINE:$COL',
' [... stack stripped ...]',
' at Test. ($TEST/teardown.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...'
]
);
}),
typeof Promise === 'function' ? [
'# teardown is only ever called once, even when async',
'ok ' + (11 + v.nonFunctions.length) + ' passes',
'# teardown: once?',
'# success (promise)',
'ok ' + (12 + v.nonFunctions.length) + ' should be truthy',
'# success (promise) teardown: 1',
'# success (promise) teardown: 2',
'# success (promise) teardown: 3'
] : [
'# SKIP teardown is only ever called once, even when async',
'# SKIP success (promise)'
],
[
'',
'1..' + ((typeof Promise === 'function' ? 2 : 0) + 10 + v.nonFunctions.length),
'# tests ' + ((typeof Promise === 'function' ? 2 : 0) + 10 + v.nonFunctions.length),
'# pass ' + ((typeof Promise === 'function' ? 2 : 0) + 5),
'# fail ' + (5 + v.nonFunctions.length),
''
]
));
}));
test('success', function (t) {
t.plan(1);
t.teardown(function () {
t.comment('success teardown');
});
t.teardown(function () {
t.comment('success teardown 2');
});
t.ok('success!');
});
test('success (async)', function (t) {
t.plan(1);
t.teardown(function () {
t.comment('success (async) teardown');
});
t.teardown(function () {
t.comment('success (async) teardown 2');
});
setTimeout(function () {
t.ok('success!');
}, 10);
});
test('nested teardowns', function (t) {
t.plan(2);
t.teardown(function () {
t.comment('nested teardown (top level)');
});
t.teardown(function () {
t.comment('nested teardown (top level) 2');
});
t.test('nested success', function (st) {
st.teardown(function () {
st.comment('nested teardown (nested success level)');
});
st.teardown(function () {
st.comment('nested teardown (nested success level) 2');
});
st.ok('nested success!');
st.end();
});
t.test('nested failure', function (st) {
st.plan(1);
st.teardown(function () {
st.comment('nested teardown (nested fail level)');
});
st.teardown(function () {
st.comment('nested teardown (nested fail level) 2');
});
st.fail('nested failure!');
});
});
test('fail', function (t) {
t.plan(1);
t.teardown(function () {
t.comment('failure teardown');
});
t.teardown(function () {
t.comment('failure teardown 2');
});
t.fail('failure!');
});
test('teardown errors do not stop the next teardown fn from running', function (t) {
t.plan(1);
t.ok('teardown error test');
t.teardown(function () {
throw new SyntaxError('teardown error!');
});
t.teardown(function () {
t.comment('teardown runs after teardown error');
});
});
test('teardown given non-function fails the test', function (t) {
t.plan(1);
t.ok('non-function test');
forEach(v.nonFunctions, function (nonFunction) {
t.teardown(nonFunction);
});
});
test('teardown is only ever called once, even when async', { skip: typeof Promise !== 'function' }, function (t) {
t.plan(1);
t.teardown(function () {
t.comment('teardown: once?');
});
t.pass('passes');
return Promise.resolve();
});
test('success (promise)', { skip: typeof Promise !== 'function' }, function (t) {
t.plan(1);
t.teardown(function () {
return new Promise(function (resolve) {
t.comment('success (promise) teardown: 1');
setTimeout(resolve, 10);
}).then(function () {
t.comment('success (promise) teardown: 2');
});
});
t.teardown(function () {
t.comment('success (promise) teardown: 3');
});
setTimeout(function () {
t.ok('success!');
}, 10);
});
});
tap.test('teardown with promise', { skip: typeof Promise !== 'function', timeout: 1e3 }, function (tt) {
tt.plan(2);
tape('dummy test', function (t) {
var resolved = false;
t.teardown(function () {
tt.pass('tape teardown');
var p = Promise.resolve();
p.then(function () {
resolved = true;
});
return p;
});
t.on('end', function () {
tt.is(resolved, true);
});
t.end();
});
});
tap.test('teardown only runs once', { skip: typeof Promise !== 'function', timeout: 1e3 }, function (tt) {
tt.plan(1);
var test = tape.createHarness();
test.createStream().pipe(concat(function (body) {
tt.same(stripFullStack(body.toString('utf8')), [].concat(
'TAP version 13',
'# teardown is only called once, even with a plan',
'ok 1 passes',
'# Tearing down!',
'',
'1..1',
'# tests 1',
'# pass 1',
'',
'# ok',
''
));
}));
test('teardown is only called once, even with a plan', function (t) {
t.plan(1);
t.teardown(function () {
t.comment('Tearing down!');
});
t.pass('passes');
return Promise.resolve();
});
});
tape-5.5.2/test/throws.js 0000664 0000000 0000000 00000025062 14202055663 0015327 0 ustar 00root root 0000000 0000000 'use strict';
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var inspect = require('object-inspect');
var assign = require('object.assign');
var stripFullStack = require('./common').stripFullStack;
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.same(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# non functions',
'ok 1 should throw',
'ok 2 should throw',
'ok 3 should throw',
'ok 4 should throw',
'ok 5 should throw',
'ok 6 should throw',
'ok 7 should throw',
'ok 8 should throw',
'# function',
'not ok 9 should throw',
' ---',
' operator: throws',
' expected: undefined',
' actual: undefined',
' at: Test. ($TEST/throws.js:$LINE:$COL)',
' stack: |-',
' Error: should throw',
' [... stack stripped ...]',
' at Test. ($TEST/throws.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'# custom error messages',
'ok 10 "message" is enumerable',
"ok 11 { custom: 'error', message: 'message' }",
'ok 12 getter is still the same',
'# throws null',
'ok 13 throws null',
'# wrong type of error',
'not ok 14 throws actual',
' ---',
' operator: throws',
' expected: |-',
' [Function: TypeError]',
' actual: |-',
' { [RangeError: actual!] ' + ('cause' in Error.prototype ? '[cause]: undefined, ' : '') + "message: 'actual!' }",
' at: Test. ($TEST/throws.js:$LINE:$COL)',
' stack: |-',
' RangeError: actual!',
' at Test. ($TEST/throws.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'# object',
'ok 15 object properties are validated',
'# object with regexes',
'ok 16 object with regex values is validated',
'# similar error object',
'ok 17 throwing a similar error',
'# validate with regex',
'ok 18 regex against toString of error',
'# custom error validation',
'ok 19 error is SyntaxError',
'ok 20 error matches /value/',
'ok 21 unexpected error',
'# throwing primitives',
'ok 22 primitive: null',
'ok 23 primitive: undefined',
'ok 24 primitive: 0',
'ok 25 primitive: NaN',
'ok 26 primitive: 42',
'ok 27 primitive: Infinity',
'ok 28 primitive: \'\'',
'ok 29 primitive: \'foo\'',
'ok 30 primitive: true',
'ok 31 primitive: false',
'# ambiguous arguments',
'ok 32 Second',
'ok 33 Second',
'ok 34 Second',
'ok 35 should throw',
'not ok 36 should throw',
' ---',
' operator: throws',
' expected: |-',
' \'/Second$/\'',
' actual: |-',
' { [Error: First] ' + ('cause' in Error.prototype ? '[cause]: undefined, ' : '') + 'message: \'First\' }',
' at: Test. ($TEST/throws.js:$LINE:$COL)',
' stack: |-',
' Error: First',
' at throwingFirst ($TEST/throws.js:$LINE:$COL)',
' [... stack stripped ...]',
' at Test. ($TEST/throws.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..36',
'# tests 36',
'# pass 33',
'# fail 3',
''
]);
}));
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();
});
test('wrong type of error', function (t) {
t.plan(1);
var actual = new RangeError('actual!');
t.throws(function () { throw actual; }, TypeError, 'throws actual');
t.end();
});
// taken from https://nodejs.org/api/assert.html#assert_assert_throws_fn_error_message
var err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
nested: true,
baz: 'text'
};
err.reg = /abc/i;
test('object', function (t) {
t.plan(1);
t.throws(
function () { throw err; },
{
name: 'TypeError',
message: 'Wrong value',
info: {
nested: true,
baz: 'text'
}
// Only properties on the validation object will be tested for.
// Using nested objects requires all properties to be present. Otherwise
// the validation is going to fail.
},
'object properties are validated'
);
t.end();
});
test('object with regexes', function (t) {
t.plan(1);
t.throws(
function () { throw err; },
{
// The `name` and `message` properties are strings and using regular
// expressions on those will match against the string. If they fail, an
// error is thrown.
name: /^TypeError$/,
message: /Wrong/,
foo: 'bar',
info: {
nested: true,
// It is not possible to use regular expressions for nested properties!
baz: 'text'
},
// The `reg` property contains a regular expression and only if the
// validation object contains an identical regular expression, it is going
// to pass.
reg: /abc/i
},
'object with regex values is validated'
);
t.end();
});
test('similar error object', function (t) {
t.plan(1);
t.throws(
function () {
var otherErr = new TypeError('Not found');
// Copy all enumerable properties from `err` to `otherErr`.
assign(otherErr, err);
throw otherErr;
},
// The error's `message` and `name` properties will also be checked when using
// an error as validation object.
err,
'throwing a similar error'
);
t.end();
});
test('validate with regex', function (t) {
t.plan(1);
t.throws(
function () { throw new Error('Wrong value'); },
/^Error: Wrong value$/,
'regex against toString of error'
);
t.end();
});
test('custom error validation', function (t) {
t.plan(3);
t.throws(
function () { throw new SyntaxError('Wrong value'); },
function (error) {
t.ok(error instanceof SyntaxError, 'error is SyntaxError');
t.ok((/value/).test(error), 'error matches /value/');
// Avoid returning anything from validation functions besides `true`.
// Otherwise, it's not clear what part of the validation failed. Instead,
// throw an error about the specific validation that failed (as done in this
// example) and add as much helpful debugging information to that error as
// possible.
return true;
},
'unexpected error'
);
t.end();
});
test('throwing primitives', function (t) {
[null, undefined, 0, NaN, 42, Infinity, '', 'foo', true, false].forEach(function (primitive) {
t.throws(function () { throw primitive; }, 'primitive: ' + inspect(primitive));
});
t.end();
});
test('ambiguous arguments', function (t) {
function throwingFirst() {
throw new Error('First');
}
function throwingSecond() {
throw new Error('Second');
}
function notThrowing() {}
// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
t.throws(throwingFirst, 'Second');
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
t.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]
// The string is only used (as message) in case the function does not throw:
t.doesNotThrow(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second
// If it was intended to match for the error message do this instead:
// It does not fail because the error messages match.
t.throws(throwingSecond, /Second$/);
// If the error message does not match, an AssertionError is thrown.
t.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]
t.end();
});
});
tape-5.5.2/test/timeout.js 0000664 0000000 0000000 00000000440 14202055663 0015460 0 ustar 00root root 0000000 0000000 'use strict';
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-5.5.2/test/timeoutAfter.js 0000664 0000000 0000000 00000005314 14202055663 0016447 0 ustar 00root root 0000000 0000000 'use strict';
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 timeoutAfter timed out after 1ms',
' ---',
' operator: fail',
' stack: |-',
' Error: timeoutAfter timed out after 1ms',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
};
test.createStream().pipe(concat(tc));
test('timeoutAfter', function (t) {
t.plan(1);
t.timeoutAfter(1);
});
});
tap.test('timeoutAfter with Promises', { skip: typeof Promise === 'undefined' }, function (tt) {
tt.plan(1);
var test = tape.createHarness();
var tc = function (rows) {
tt.same(stripFullStack(rows.toString('utf8')), [
'TAP version 13',
'# timeoutAfter with promises',
'# fulfilled promise',
'not ok 1 fulfilled promise timed out after 1ms',
' ---',
' operator: fail',
' stack: |-',
' Error: fulfilled promise timed out after 1ms',
' [... stack stripped ...]',
' ...',
'# rejected promise',
'not ok 2 rejected promise timed out after 1ms',
' ---',
' operator: fail',
' stack: |-',
' Error: rejected promise timed out after 1ms',
' [... stack stripped ...]',
' ...',
'',
'1..2',
'# tests 2',
'# pass 0',
'# fail 2',
''
]);
};
test.createStream().pipe(concat(tc));
test('timeoutAfter with promises', function (t) {
t.plan(2);
t.test('fulfilled promise', function (st) {
st.plan(1);
st.timeoutAfter(1);
return new Promise(function (resolve) {
setTimeout(function () {
resolve();
}, 10);
});
});
t.test('rejected promise', function (st) {
st.plan(1);
st.timeoutAfter(1);
return new Promise(function (reject) {
setTimeout(function () {
reject();
}, 10);
});
});
});
});
tape-5.5.2/test/todo.js 0000664 0000000 0000000 00000002147 14202055663 0014745 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var tape = require('../');
var concat = require('concat-stream');
var common = require('./common');
var stripFullStack = common.stripFullStack;
tap.test('tape todo test', function (assert) {
var test = tape.createHarness({ exit: false });
assert.plan(1);
test.createStream().pipe(concat(function (body) {
assert.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# success',
'ok 1 this test runs',
'# TODO failure',
'not ok 2 should never happen # TODO',
' ---',
' operator: fail',
' at: Test. ($TEST/todo.js:$LINE:$COL)',
' ...',
'',
'1..2',
'# tests 2',
'# pass 2',
'',
'# ok',
''
]);
}));
test('success', function (t) {
t.equal(true, true, 'this test runs');
t.end();
});
test('failure', { todo: true }, function (t) {
t.fail('should never happen');
t.end();
});
});
tape-5.5.2/test/todo_explanation.js 0000664 0000000 0000000 00000004200 14202055663 0017337 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var tape = require('../');
var concat = require('concat-stream');
var common = require('./common');
var stripFullStack = common.stripFullStack;
tap.test('tape todo test', { todo: process.versions.node.match(/0\.8\.\d+/) ? 'Fails on node 0.8' : false }, function (assert) {
var test = tape.createHarness({ exit: false });
assert.plan(1);
test.createStream().pipe(concat(function (body) {
assert.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# success',
'ok 1 this test runs',
'# TODO incomplete test1',
'not ok 2 check output # TODO',
' ---',
' operator: equal',
' expected: false',
' actual: true',
' at: Test. ($TEST/todo_explanation.js:$LINE:$COL)',
' ...',
'not ok 3 check vars output # TODO name conflict',
' ---',
' operator: equal',
' expected: 0',
' actual: 1',
' at: Test. ($TEST/todo_explanation.js:$LINE:$COL)',
' ...',
'# incomplete test2',
'not ok 4 run openssl # TODO installer needs fix',
' ---',
' operator: fail',
' at: Test. ($TEST/todo_explanation.js:$LINE:$COL)',
' ...',
'# TODO passing test',
'',
'1..4',
'# tests 4',
'# pass 4',
'',
'# ok',
''
]);
}));
test('success', function (t) {
t.equal(true, true, 'this test runs');
t.end();
});
test('incomplete test1', { todo: true }, function (t) {
t.equal(true, false, 'check output');
t.equal(1, 0, 'check vars output', { todo: 'name conflict' });
t.end();
});
test('incomplete test2', function (t) {
t.fail('run openssl', { todo: 'installer needs fix' });
t.end();
});
test('passing test', { todo: 'yet incomplete' }, function (t) {
t.end();
});
});
tape-5.5.2/test/todo_single.js 0000664 0000000 0000000 00000002010 14202055663 0016273 0 ustar 00root root 0000000 0000000 'use strict';
var tap = require('tap');
var tape = require('../');
var concat = require('concat-stream');
var common = require('./common');
var stripFullStack = common.stripFullStack;
tap.test('tape todo test', function (assert) {
var test = tape.createHarness({ exit: false });
assert.plan(1);
test.createStream().pipe(concat(function (body) {
assert.deepEqual(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# TODO failure',
'not ok 1 should be strictly equal # TODO',
' ---',
' operator: equal',
' expected: false',
' actual: true',
' at: Test. ($TEST/todo_single.js:$LINE:$COL)',
' ...',
'',
'1..1',
'# tests 1',
'# pass 1',
'',
'# ok',
''
]);
}));
test('failure', { todo: true }, function (t) {
t.equal(true, false);
t.end();
});
});
tape-5.5.2/test/too_many.js 0000664 0000000 0000000 00000004536 14202055663 0015631 0 ustar 00root root 0000000 0000000 'use strict';
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 deeply equivalent',
'ok 2 should be deeply equivalent',
'ok 3 should be deeply equivalent',
'ok 4 should be deeply 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 deeply equivalent',
'',
'1..6',
'# tests 6',
'# pass 5',
'# fail 1',
''
]);
};
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-5.5.2/test/undef.js 0000664 0000000 0000000 00000002363 14202055663 0015101 0 ustar 00root root 0000000 0000000 'use strict';
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.same(stripFullStack(body.toString('utf8')), [
'TAP version 13',
'# undef',
'not ok 1 should be deeply equivalent',
' ---',
' operator: deepEqual',
' expected: |-',
' { beep: undefined }',
' actual: |-',
' {}',
' at: Test. ($TEST/undef.js:$LINE:$COL)',
' stack: |-',
' Error: should be deeply equivalent',
' [... stack stripped ...]',
' at Test. ($TEST/undef.js:$LINE:$COL)',
' [... stack stripped ...]',
' ...',
'',
'1..1',
'# tests 1',
'# pass 0',
'# fail 1',
''
]);
}));
test('undef', function (t) {
t.plan(1);
t.deepEqual({}, { beep: undefined });
});
});