pax_global_header00006660000000000000000000000064142020556630014515gustar00rootroot0000000000000052 comment=e6f091a78fd5e611c616fabff6a4e10c2af3ac4c tape-5.5.2/000077500000000000000000000000001420205566300124575ustar00rootroot00000000000000tape-5.5.2/.editorconfig000066400000000000000000000010371420205566300151350ustar00rootroot00000000000000root = 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/.eslintrc000066400000000000000000000066221420205566300143110ustar00rootroot00000000000000{ "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/000077500000000000000000000000001420205566300140175ustar00rootroot00000000000000tape-5.5.2/.github/workflows/000077500000000000000000000000001420205566300160545ustar00rootroot00000000000000tape-5.5.2/.github/workflows/node-aught.yml000066400000000000000000000005161420205566300206340ustar00rootroot00000000000000name: '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.yml000066400000000000000000000002061420205566300212060ustar00rootroot00000000000000name: '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.yml000066400000000000000000000005211420205566300204710ustar00rootroot00000000000000name: '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.yml000066400000000000000000000004111420205566300200340ustar00rootroot00000000000000name: 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.yml000066400000000000000000000003031420205566300224710ustar00rootroot00000000000000name: 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/.gitignore000066400000000000000000000002021420205566300144410ustar00rootroot00000000000000# gitignore /node_modules # Only apps should have lockfiles yarn.lock package-lock.json # coverage data coverage/ .nyc_output/ tape-5.5.2/.npmignore000066400000000000000000000002251420205566300144550ustar00rootroot00000000000000# gitignore /node_modules # Only apps should have lockfiles yarn.lock package-lock.json # coverage data coverage/ .nyc_output/ .github/workflows tape-5.5.2/.npmrc000066400000000000000000000000231420205566300135720ustar00rootroot00000000000000package-lock=false tape-5.5.2/.nycrc000066400000000000000000000002661420205566300136020ustar00rootroot00000000000000{ "all": true, "check-coverage": false, "reporter": ["text-summary", "text", "html", "json"], "exclude": [ "bin/import-or-require.js", "coverage", "example", "test" ] } tape-5.5.2/LICENSE000066400000000000000000000020571420205566300134700ustar00rootroot00000000000000MIT 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/000077500000000000000000000000001420205566300132275ustar00rootroot00000000000000tape-5.5.2/bin/import-or-require.js000066400000000000000000000007101420205566300171650ustar00rootroot00000000000000'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/tape000077500000000000000000000053571420205566300141200ustar00rootroot00000000000000#!/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/000077500000000000000000000000001420205566300141125ustar00rootroot00000000000000tape-5.5.2/example/array.js000066400000000000000000000014141420205566300155660ustar00rootroot00000000000000'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.js000066400000000000000000000014361420205566300153670ustar00rootroot00000000000000'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.js000066400000000000000000000020761420205566300157370ustar00rootroot00000000000000'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.js000066400000000000000000000021001420205566300167160ustar00rootroot00000000000000'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.js000066400000000000000000000000771420205566300167040ustar00rootroot00000000000000'use strict'; var test = require('../'); test('No cb test'); tape-5.5.2/example/not_enough_fail.js000066400000000000000000000013731420205566300176140ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300154015ustar00rootroot00000000000000tape-5.5.2/example/static/build.sh000077500000000000000000000000611420205566300170340ustar00rootroot00000000000000#!/bin/bash browserify ../timing.js -o bundle.js tape-5.5.2/example/static/index.html000066400000000000000000000005421420205566300173770ustar00rootroot00000000000000 tape-5.5.2/example/static/server.js000066400000000000000000000002311420205566300172410ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300154055ustar00rootroot00000000000000tape-5.5.2/example/stream/object.js000066400000000000000000000004161420205566300172120ustar00rootroot00000000000000'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.js000066400000000000000000000003121420205566300165230ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300163645ustar00rootroot00000000000000tape-5.5.2/example/stream/test/x_fail.js000066400000000000000000000001641420205566300201650ustar00rootroot00000000000000'use strict'; var test = require('../../../'); test(function (t) { t.plan(1); t.equal('beep', 'boop'); }); tape-5.5.2/example/stream/test/y.js000066400000000000000000000002751420205566300171760ustar00rootroot00000000000000'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.js000066400000000000000000000002471420205566300166110ustar00rootroot00000000000000'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.js000066400000000000000000000003731420205566300157420ustar00rootroot00000000000000'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.js000066400000000000000000000013751420205566300172760ustar00rootroot00000000000000'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.js000066400000000000000000000005311420205566300152600ustar00rootroot00000000000000'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.js000066400000000000000000000114451420205566300141310ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300132255ustar00rootroot00000000000000tape-5.5.2/lib/default_stream.js000066400000000000000000000017101420205566300165610ustar00rootroot00000000000000'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.js000066400000000000000000000150211420205566300152630ustar00rootroot00000000000000'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.js000066400000000000000000000551441420205566300145530ustar00rootroot00000000000000'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.json000066400000000000000000000061531420205566300147520ustar00rootroot00000000000000{ "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.markdown000066400000000000000000000525361420205566300154730ustar00rootroot00000000000000# 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] ![tape](https://web.archive.org/web/20170612184731if_/http://substack.net/images/tape_drive.png) # 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/000077500000000000000000000000001420205566300134365ustar00rootroot00000000000000tape-5.5.2/test/add-subtest-async.js000066400000000000000000000003651420205566300173320ustar00rootroot00000000000000'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.js000066400000000000000000000024351420205566300164310ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300160675ustar00rootroot00000000000000tape-5.5.2/test/anonymous-fn/test-wrapper.js000066400000000000000000000004471420205566300210670ustar00rootroot00000000000000'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.js000066400000000000000000000030631420205566300151140ustar00rootroot00000000000000'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.js000066400000000000000000000227251420205566300162240ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300156565ustar00rootroot00000000000000tape-5.5.2/test/async-await/async-bug.js000066400000000000000000000010401420205566300200770ustar00rootroot00000000000000'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.js000066400000000000000000000003421420205566300204570ustar00rootroot00000000000000'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.js000066400000000000000000000005121420205566300174100ustar00rootroot00000000000000'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.js000066400000000000000000000004721420205566300174160ustar00rootroot00000000000000'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.js000066400000000000000000000003511420205566300174130ustar00rootroot00000000000000'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.js000066400000000000000000000006111420205566300174130ustar00rootroot00000000000000'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.js000066400000000000000000000027011420205566300174160ustar00rootroot00000000000000'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.js000066400000000000000000000003501420205566300203150ustar00rootroot00000000000000'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.js000066400000000000000000000003211420205566300150770ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300151215ustar00rootroot00000000000000tape-5.5.2/test/browser/asserts.js000066400000000000000000000003441420205566300171440ustar00rootroot00000000000000'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.js000066400000000000000000000026371420205566300167600ustar00rootroot00000000000000'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.js000066400000000000000000000025351420205566300170770ustar00rootroot00000000000000'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.js000066400000000000000000000111031420205566300154320ustar00rootroot00000000000000'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.js000066400000000000000000000075131420205566300152720ustar00rootroot00000000000000'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.js000066400000000000000000000013001420205566300207020ustar00rootroot00000000000000'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.js000066400000000000000000000145241420205566300174510ustar00rootroot00000000000000'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.js000066400000000000000000000025621420205566300147160ustar00rootroot00000000000000'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.js000066400000000000000000000033611420205566300172300ustar00rootroot00000000000000'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.js000066400000000000000000000040051420205566300160730ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300155365ustar00rootroot00000000000000tape-5.5.2/test/double_end/double.js000066400000000000000000000003011420205566300173400ustar00rootroot00000000000000'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.js000066400000000000000000000260511420205566300160000ustar00rootroot00000000000000'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.js000066400000000000000000000045521420205566300167030ustar00rootroot00000000000000'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.js000066400000000000000000000020621420205566300151250ustar00rootroot00000000000000'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.js000066400000000000000000000163001420205566300147450ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300144075ustar00rootroot00000000000000tape-5.5.2/test/exit/fail.js000066400000000000000000000014011420205566300156540ustar00rootroot00000000000000'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.js000066400000000000000000000002501420205566300172410ustar00rootroot00000000000000'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.js000066400000000000000000000014231420205566300153560ustar00rootroot00000000000000'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.js000066400000000000000000000002601420205566300162160ustar00rootroot00000000000000'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.js000066400000000000000000000002021420205566300157040ustar00rootroot00000000000000'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.js000066400000000000000000000002031420205566300167000ustar00rootroot00000000000000'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.js000066400000000000000000000013761420205566300164160ustar00rootroot00000000000000'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.js000066400000000000000000000004531420205566300171060ustar00rootroot00000000000000'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.js000066400000000000000000000045771420205566300147240ustar00rootroot00000000000000'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.js000066400000000000000000000021661420205566300160130ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300147215ustar00rootroot00000000000000tape-5.5.2/test/ignore/.ignore000066400000000000000000000000221420205566300161770ustar00rootroot00000000000000fake_node_modules tape-5.5.2/test/ignore/fake_node_modules/000077500000000000000000000000001420205566300203645ustar00rootroot00000000000000tape-5.5.2/test/ignore/fake_node_modules/stub1.js000066400000000000000000000001751420205566300217630ustar00rootroot00000000000000'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.js000066400000000000000000000001731420205566300217620ustar00rootroot00000000000000'use strict'; var tape = require('../../../'); tape.test(function (t) { t.fail('Should not print'); t.end(); }); tape-5.5.2/test/ignore/test.js000066400000000000000000000001541420205566300162360ustar00rootroot00000000000000'use strict'; var tape = require('../../'); tape.test(function (t) { t.plan(1); t.ok('Okay'); }); tape-5.5.2/test/ignore/test/000077500000000000000000000000001420205566300157005ustar00rootroot00000000000000tape-5.5.2/test/ignore/test/stub1.js000066400000000000000000000001671420205566300173000ustar00rootroot00000000000000'use strict'; var tape = require('../../../'); tape.test(function (t) { t.plan(1); t.pass('test/stub1'); }); tape-5.5.2/test/ignore/test/stub2.js000066400000000000000000000001651420205566300172770ustar00rootroot00000000000000'use strict'; var tape = require('../../../'); tape.test(function (t) { t.pass('test/stub2'); t.end(); }); tape-5.5.2/test/ignore/test/sub/000077500000000000000000000000001420205566300164715ustar00rootroot00000000000000tape-5.5.2/test/ignore/test/sub/sub.stub1.js000066400000000000000000000001761420205566300206610ustar00rootroot00000000000000'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.js000066400000000000000000000001741420205566300206600ustar00rootroot00000000000000'use strict'; var tape = require('../../../../'); tape.test(function (t) { t.pass('test/sub/stub2'); t.end(); }); tape-5.5.2/test/ignore/test2.js000066400000000000000000000001641420205566300163210ustar00rootroot00000000000000'use strict'; var tape = require('../../'); tape.test(function (t) { t.pass('Should print'); t.end(); }); tape-5.5.2/test/ignore_from_gitignore.js000066400000000000000000000074671420205566300203670ustar00rootroot00000000000000'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.js000066400000000000000000000154451420205566300153170ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300147505ustar00rootroot00000000000000tape-5.5.2/test/import/mjs-a.mjs000066400000000000000000000002111420205566300164640ustar00rootroot00000000000000import 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.mjs000066400000000000000000000002401420205566300164670ustar00rootroot00000000000000import 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.mjs000066400000000000000000000002401420205566300164700ustar00rootroot00000000000000import 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.mjs000066400000000000000000000002401420205566300164710ustar00rootroot00000000000000import 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.mjs000066400000000000000000000002401420205566300164720ustar00rootroot00000000000000import 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.mjs000066400000000000000000000002401420205566300164730ustar00rootroot00000000000000import 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.mjs000066400000000000000000000002401420205566300164740ustar00rootroot00000000000000import 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.mjs000066400000000000000000000002071420205566300165000ustar00rootroot00000000000000import 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/000077500000000000000000000000001420205566300174045ustar00rootroot00000000000000tape-5.5.2/test/import/package_type/package-a.js000066400000000000000000000002361420205566300215540ustar00rootroot00000000000000import 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.js000066400000000000000000000003071420205566300215540ustar00rootroot00000000000000import 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.js000066400000000000000000000002451420205566300215560ustar00rootroot00000000000000import 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.json000066400000000000000000000000311420205566300216640ustar00rootroot00000000000000{ "type": "module" } tape-5.5.2/test/import/syntax-error.cjs000066400000000000000000000000031420205566300201170ustar00rootroot00000000000000)) tape-5.5.2/test/import/syntax-error.mjs000066400000000000000000000000031420205566300201310ustar00rootroot00000000000000)) tape-5.5.2/test/import/throws.cjs000066400000000000000000000000521420205566300167740ustar00rootroot00000000000000'use strict'; throw new Error('thrown'); tape-5.5.2/test/import/throws.mjs000066400000000000000000000000331420205566300170050ustar00rootroot00000000000000throw new Error('thrown'); tape-5.5.2/test/many.js000066400000000000000000000003171420205566300147410ustar00rootroot00000000000000'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.js000066400000000000000000000254721420205566300151020ustar00rootroot00000000000000'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.js000066400000000000000000000004561420205566300166560ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300163135ustar00rootroot00000000000000tape-5.5.2/test/max_listeners/source.js000066400000000000000000000002461420205566300201530ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300152455ustar00rootroot00000000000000tape-5.5.2/test/messages/defaults.js000066400000000000000000000007211420205566300174120ustar00rootroot00000000000000'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.js000066400000000000000000000016301420205566300204220ustar00rootroot00000000000000'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.js000066400000000000000000000021231420205566300206140ustar00rootroot00000000000000'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.js000066400000000000000000000041231420205566300152560ustar00rootroot00000000000000'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.js000066400000000000000000000005231420205566300153400ustar00rootroot00000000000000'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.js000066400000000000000000000022441420205566300162260ustar00rootroot00000000000000'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.js000066400000000000000000000074401420205566300154560ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300151135ustar00rootroot00000000000000tape-5.5.2/test/no_only/test-a.js000066400000000000000000000001661420205566300166510ustar00rootroot00000000000000'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.js000066400000000000000000000003131420205566300166440ustar00rootroot00000000000000'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.js000066400000000000000000000150371420205566300202470ustar00rootroot00000000000000'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.js000066400000000000000000000037351420205566300173360ustar00rootroot00000000000000'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.js000066400000000000000000000171411420205566300156250ustar00rootroot00000000000000'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.js000066400000000000000000000036001420205566300160460ustar00rootroot00000000000000'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.js000066400000000000000000000017221420205566300202300ustar00rootroot00000000000000'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.js000066400000000000000000000010771420205566300157250ustar00rootroot00000000000000'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.js000066400000000000000000000004301420205566300155460ustar00rootroot00000000000000'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.js000066400000000000000000000007221420205566300160670ustar00rootroot00000000000000'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.js000066400000000000000000000017761420205566300147700ustar00rootroot00000000000000'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.js000066400000000000000000000002331420205566300150350ustar00rootroot00000000000000'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.js000066400000000000000000000003731420205566300150430ustar00rootroot00000000000000'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.js000066400000000000000000000003121420205566300150350ustar00rootroot00000000000000'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.js000066400000000000000000000003121420205566300150360ustar00rootroot00000000000000'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.js000066400000000000000000000004541420205566300151120ustar00rootroot00000000000000'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.js000066400000000000000000000004531420205566300166350ustar00rootroot00000000000000'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.js000066400000000000000000000076771420205566300164660ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300152775ustar00rootroot00000000000000tape-5.5.2/test/promises/fail.js000066400000000000000000000007161420205566300165540ustar00rootroot00000000000000'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.js000066400000000000000000000011111420205566300174430ustar00rootroot00000000000000'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.js000066400000000000000000000036411420205566300154540ustar00rootroot00000000000000'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/000077500000000000000000000000001420205566300151125ustar00rootroot00000000000000tape-5.5.2/test/require/a.js000066400000000000000000000002351420205566300156700ustar00rootroot00000000000000'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.js000066400000000000000000000002351420205566300156710ustar00rootroot00000000000000'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.js000066400000000000000000000003211420205566300166410ustar00rootroot00000000000000'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.js000066400000000000000000000003211420205566300166420ustar00rootroot00000000000000'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.js000066400000000000000000000021111420205566300147350ustar00rootroot00000000000000'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.js000066400000000000000000000052771420205566300173570ustar00rootroot00000000000000'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.js000066400000000000000000000211421420205566300160600ustar00rootroot00000000000000'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.js000066400000000000000000000004521420205566300156370ustar00rootroot00000000000000'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.js000066400000000000000000000011571420205566300175100ustar00rootroot00000000000000'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.js000066400000000000000000000007171420205566300165040ustar00rootroot00000000000000'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.js000066400000000000000000000246701420205566300156300ustar00rootroot00000000000000'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.js000066400000000000000000000250621420205566300153270ustar00rootroot00000000000000'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.js000066400000000000000000000004401420205566300154600ustar00rootroot00000000000000'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.js000066400000000000000000000053141420205566300164470ustar00rootroot00000000000000'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.js000066400000000000000000000021471420205566300147450ustar00rootroot00000000000000'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.js000066400000000000000000000042001420205566300173370ustar00rootroot00000000000000'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.js000066400000000000000000000020101420205566300162730ustar00rootroot00000000000000'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.js000066400000000000000000000045361420205566300156310ustar00rootroot00000000000000'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.js000066400000000000000000000023631420205566300151010ustar00rootroot00000000000000'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 }); }); });