Reformat all files with prettier

             @@ -2,11 +2,8 @@     2      2  "presets": ["es2015"],     3      3  "env": {     4      4    "test": {     5             "plugins": [     6               "source-map-support-for-6",     7               "istanbul"     8             ],     9             "sourceMaps": "inline",            5      "plugins": ["source-map-support-for-6", "istanbul"],            6      "sourceMaps": "inline"    10      7    }    11      8  }    12      9}

             @@ -2,27 +2,28 @@     2      2     3      3JavaScript TAP test framework highly inspired by [tape](https://www.npmjs.com/package/tape) and [AVA](https://www.npmjs.com/package/ava).     4      4     5       * **Simple:** Works in Node and browsers, simply import or require it to use. API is very similar to tape and AVA. 100% test coverage.     6       * **Concurrent:** All asynchronous tests are run concurrently. Forces to write isolated from each other test cases that don't share a global state.     7       * **Useful Features:** Synchronous and asynchronous tests, support for Promises, before/after/beforeEach/afterEach hooks, clean stacktraces.            5- **Simple:** Works in Node and browsers, simply import or require it to use. API is very similar to tape and AVA. 100% test coverage.            6- **Concurrent:** All asynchronous tests are run concurrently. Forces to write isolated from each other test cases that don't share a global state.            7- **Useful Features:** Synchronous and asynchronous tests, support for Promises, before/after/beforeEach/afterEach hooks, clean stacktraces.     8      8     9      9## USAGE    10     10    11     11```js    12       import createSuite from 'estap';    13       const test = createSuite();    14           15       test('add', t => {    16         t.is(add(1, 2), 3, '1 + 2 === 3');    17       });    18           19       test('delay promise', t => new Promise(resolve => {    20         t.pass('setting a timeout');    21         setTimeout(resolve, 1000);    22       }));    23           24       test.cb('delay callback', t => {    25         t.pass('setting a timeout');           12import createSuite from "estap";           13const test = createSuite();           14           15test("add", (t) => {           16  t.is(add(1, 2), 3, "1 + 2 === 3");           17});           18           19test("delay promise", (t) =>           20  new Promise((resolve) => {           21    t.pass("setting a timeout");           22    setTimeout(resolve, 1000);           23  }));           24           25test.cb("delay callback", (t) => {           26  t.pass("setting a timeout");    26     27  setTimeout(t.end, 1000);    27     28});    28     29```             @@ -117,23 +118,22 @@   117    118Everything runs concurrently in the same Node process/browser context. However it's possible to synchronize access to any shared resource using locks.   118    119   119    120```js   120       import { default as createSuite, createLock } from 'estap';          121import { default as createSuite, createLock } from "estap";   121    122const test = createSuite();   122    123const lock = createLock();   123    124   124       test.beforeEach('setup database', t => {   125         return lock.acquire()   126           .then(() => t.pass('resetting database...'));   127       });   128          129       test.afterEach('release database', lock.release);          125test.beforeEach("setup database", (t) => {          126  return lock.acquire().then(() => t.pass("resetting database..."));          127});          128          129test.afterEach("release database", lock.release);   130    130```   131    131   132    132### Thanks to   133    133   134       * @substack for [tape](https://www.npmjs.com/package/tape), tap-producing test harness for node and browsers, source for many ideas.   135          136       * @sindresorhus and AVA team for [AVA](https://github.com/avajs/ava), Futuristic JavaScript test runner, source for many ideas.          134- @substack for [tape](https://www.npmjs.com/package/tape), tap-producing test harness for node and browsers, source for many ideas.          135          136- @sindresorhus and AVA team for [AVA](https://github.com/avajs/ava), Futuristic JavaScript test runner, source for many ideas.   137    137   138    138### License   139    139

             @@ -1,4 +1,4 @@     1       import estap from '../lib';            1import estap from "../lib";     2      2     3      3const test = estap();     4      4             @@ -6,16 +6,17 @@     6      6  return a + b;     7      7}     8      8     9       test('add', t => {    10         t.is(add(1, 2), 3, '1 + 2 === 3');    11       });    12           13       test('delay promise', t => new Promise(resolve => {    14         t.pass('setting a timeout');    15         setTimeout(resolve, 1000);    16       }));    17           18       test.cb('delay callback', t => {    19         t.pass('setting a timeout');            9test("add", (t) => {           10  t.is(add(1, 2), 3, "1 + 2 === 3");           11});           12           13test("delay promise", (t) =>           14  new Promise((resolve) => {           15    t.pass("setting a timeout");           16    setTimeout(resolve, 1000);           17  }));           18           19test.cb("delay callback", (t) => {           20  t.pass("setting a timeout");    20     21  setTimeout(t.end, 1000);    21     22});

             @@ -1,17 +1,18 @@     1       import { default as createSuite, createLock } from '../lib';            1import { default as createSuite, createLock } from "../lib";     2      2     3      3const test = createSuite();     4      4const lock = createLock();     5      5     6       test.beforeEach('setup database', t => lock.acquire()     7         .then(() => t.pass('resetting database...')));     8            9       test.afterEach('release database', lock.release);    10           11       test('use db 1', t => {    12         t.pass('use database 1');    13       });    14           15       test('use db 2', t => {    16         t.pass('use database 2');            6test.beforeEach("setup database", (t) =>            7  lock.acquire().then(() => t.pass("resetting database...")),            8);            9           10test.afterEach("release database", lock.release);           11           12test("use db 1", (t) => {           13  t.pass("use database 1");           14});           15           16test("use db 2", (t) => {           17  t.pass("use database 2");    17     18});

             @@ -1,9 +1,9 @@     1       import deepEqual from 'deep-equal';     2       import objectAssign from 'object-assign';     3       import { extractErrorStack } from './stack-filter';            1import deepEqual from "deep-equal";            2import objectAssign from "object-assign";            3import { extractErrorStack } from "./stack-filter";     4      4     5      5function isValidPlan(value) {     6         return typeof value === 'number' && Math.floor(value) === value && value > 0;            6  return typeof value === "number" && Math.floor(value) === value && value > 0;     7      7}     8      8     9      9export default function (test, testOpts, context = null) {             @@ -15,25 +15,30 @@    15     15  const afterFns = [];    16     16    17     17  const assert = function ESTAP_ASSERT__(value, opts) {    18           if (ended && opts.op !== 'end') {           18    if (ended && opts.op !== "end") {    19     19      // throw here because it can happen later after the test completion    20             throw new Error('assertion after end');           20      throw new Error("assertion after end");    21     21    }    22     22    23     23    if (!value) {    24     24      ++testOpts.assertionCount;    25     25      ++testOpts.assertionFailed;    26             testOpts.log(objectAssign({    27               type: 'error',    28               test: test.name,    29               stack: extractErrorStack(new Error()),    30             }, opts));           26      testOpts.log(           27        objectAssign(           28          {           29            type: "error",           30            test: test.name,           31            stack: extractErrorStack(new Error()),           32          },           33          opts,           34        ),           35      );    31     36    } else {    32     37      ++count;    33     38      ++testOpts.assertionCount;    34             testOpts.log({ type: 'ok', test: test.name, message: opts.message });    35           36             if (test.type === 'cb' && count === plan) {           39      testOpts.log({ type: "ok", test: test.name, message: opts.message });           40           41      if (test.type === "cb" && count === plan) {    37     42        assertEnd();    38     43      }    39     44    }             @@ -40,15 +45,15 @@    40     45  };    41     46    42     47  function testEnd() {    43           afterFns.forEach(fn => fn());           48    afterFns.forEach((fn) => fn());    44     49    45     50    if (plan > 0 && count !== plan) {    46     51      ++testOpts.assertionCount;    47     52      ++testOpts.assertionFailed;    48     53      testOpts.log({    49               type: 'error',    50               op: 'plan',    51               message: 'assertions count does not match plan',           54        type: "error",           55        op: "plan",           56        message: "assertions count does not match plan",    52     57        actual: count,    53     58        expected: plan,    54     59        test: test.name,             @@ -62,10 +67,10 @@    62     67  }    63     68    64     69  function assertEnd(val) {    65           if (test.type !== 'cb') {    66             assert(false, {    67               message: 'only callback tests require end',    68               op: 'end',           70    if (test.type !== "cb") {           71      assert(false, {           72        message: "only callback tests require end",           73        op: "end",    69     74      });    70     75      return;    71     76    }             @@ -72,8 +77,8 @@    72     77    73     78    if (ended) {    74     79      assert(false, {    75               message: 'end called multiple times',    76               op: 'end',           80        message: "end called multiple times",           81        op: "end",    77     82      });    78     83      return;    79     84    }             @@ -82,9 +87,9 @@    82     87    83     88    if (val) {    84     89      assert(false, {    85               message: 'end value should be falsy',           90        message: "end value should be falsy",    86     91        actual: val,    87               op: 'end',           92        op: "end",    88     93      });    89     94    }    90     95             @@ -92,217 +97,235 @@    92     97    onEndHandler();    93     98  }    94     99    95         return [{    96           plan(num) {    97             if (!isValidPlan(num)) {    98               assert(false, {    99                 message: 'plan value is not a positive integer',   100                 actual: num,   101                 op: 'plan',   102               });   103               return;   104             }   105          106             if (plan > 0) {   107               assert(false, {   108                 message: 'plan can only be set once',   109                 op: 'plan',   110               });   111               return;   112             }   113          114             plan = num;   115           },   116           end: assertEnd,   117           pass(message) {   118             assert(true, {   119               message: message || 'pass',   120               actual: null,   121               expected: null,   122               op: 'fail',   123             });   124           },   125           fail(message) {   126             assert(false, {   127               message: message || 'fail',   128               actual: null,   129               expected: null,   130               op: 'fail',   131             });   132           },   133           is(actual, expected, message) {   134             assert(actual === expected, {   135               message: message || 'is',   136               actual,   137               expected,   138               op: 'is',   139             });   140           },   141           not(actual, expected, message) {   142             assert(actual !== expected, {   143               message: message || 'not',   144               actual,   145               expected,   146               op: 'not',   147             });   148           },   149           truthy(actual, message) {   150             assert(actual, {   151               message: message || 'truthy',   152               actual,   153               expected: null,   154               op: 'truthy',   155             });   156           },   157           falsy(actual, message) {   158             assert(!actual, {   159               message: message || 'falsy',   160               actual,   161               expected: null,   162               op: 'falsy',   163             });   164           },   165           true(actual, message) {   166             assert(actual === true, {   167               message: message || 'true',   168               actual,   169               expected: true,   170               op: 'true',   171             });   172           },   173           false(actual, message) {   174             assert(actual === false, {   175               message: message || 'false',   176               actual,   177               expected: false,   178               op: 'false',   179             });   180           },   181           throws(fn, expectedArg, messageArg) {   182             let expected = expectedArg;   183             let message = messageArg;   184             if (typeof expectedArg === 'string') {   185               expected = void 0;   186               message = expectedArg;   187             }   188          189             try {   190               fn();   191             } catch (err) {   192               if (typeof expected === 'undefined') {   193                 assert(true, {   194                   message: message || 'throws',   195                   actual: err.constructor,   196                   expected,   197                   op: 'throws',   198                 });   199                 return;   200               }   201          202               if (typeof expected === 'function') {   203                 assert(err instanceof expected, {   204                   message: message || 'throws',   205                   actual: err.constructor,   206                   expected,   207                   op: 'throws',   208                 });   209                 return;   210               }   211          212               if (expected instanceof RegExp) {   213                 assert(expected.test(String(err)), {   214                   message: message || 'throws',   215                   actual: String(err),   216                   expected,   217                   op: 'throws',   218                 });   219                 return;   220               }   221          222               if (Array.isArray(expected) && expected.length === 2 && (expected[1] instanceof RegExp)) {   223                 assert((err instanceof expected[0]) && expected[1].test(String(err)), {   224                   message: message || 'throws',   225                   actual: [err.constructor, String(err)],   226                   expected,   227                   op: 'throws',   228                 });   229                 return;   230               }   231          232               if (Array.isArray(expected) && expected.length === 2 && (typeof expected[1] === 'string')) {   233                 assert((err instanceof expected[0]) && expected[1] === String(err.message), {   234                   message: message || 'throws',   235                   actual: [err.constructor, String(err.message)],   236                   expected,   237                   op: 'throws',   238                 });   239                 return;   240               }   241          242               assert(false, {   243                 message: message || 'throws',   244                 op: 'throws',   245                 actual: err,   246                 expected,   247               });   248               return;   249             }   250          251             if (typeof expected === 'undefined') {   252               assert(false, {   253                 message: message || 'throws',   254                 op: 'throws',   255               });   256             } else {   257               assert(false, {   258                 message: message || 'throws',   259                 expected,   260                 op: 'throws',   261               });   262             }   263           },   264           notThrows(fn, message) {   265             try {   266               fn();          100  return [          101    {          102      plan(num) {          103        if (!isValidPlan(num)) {          104          assert(false, {          105            message: "plan value is not a positive integer",          106            actual: num,          107            op: "plan",          108          });          109          return;          110        }          111          112        if (plan > 0) {          113          assert(false, {          114            message: "plan can only be set once",          115            op: "plan",          116          });          117          return;          118        }          119          120        plan = num;          121      },          122      end: assertEnd,          123      pass(message) {   267    124        assert(true, {   268                 message: message || 'notThrows',   269                 op: 'notThrows',   270               });   271             } catch (err) {   272               assert(false, {   273                 message: message || 'notThrows',   274                 actual: err,   275                 op: 'notThrows',   276               });   277             }   278           },   279           same(actual, expected, message) {   280             assert(deepEqual(actual, expected, { strict: true }), {   281               message: message || 'same',   282               actual,   283               expected,   284               op: 'same',   285             });   286           },   287           notSame(actual, expected, message) {   288             assert(!deepEqual(actual, expected, { strict: true }), {   289               message: message || 'notSame',   290               actual,   291               expected,   292               op: 'notSame',   293             });   294           },   295           after(fn) {   296             if (typeof fn !== 'function') {   297               assert(false, {   298                 message: 'after() argument 0 is not a function',   299                 op: 'after',   300               });   301               return;   302             }   303          304             afterFns.push(fn);   305           },   306           context,   307         }, testEnd, setOnEndHandler];          125          message: message || "pass",          126          actual: null,          127          expected: null,          128          op: "fail",          129        });          130      },          131      fail(message) {          132        assert(false, {          133          message: message || "fail",          134          actual: null,          135          expected: null,          136          op: "fail",          137        });          138      },          139      is(actual, expected, message) {          140        assert(actual === expected, {          141          message: message || "is",          142          actual,          143          expected,          144          op: "is",          145        });          146      },          147      not(actual, expected, message) {          148        assert(actual !== expected, {          149          message: message || "not",          150          actual,          151          expected,          152          op: "not",          153        });          154      },          155      truthy(actual, message) {          156        assert(actual, {          157          message: message || "truthy",          158          actual,          159          expected: null,          160          op: "truthy",          161        });          162      },          163      falsy(actual, message) {          164        assert(!actual, {          165          message: message || "falsy",          166          actual,          167          expected: null,          168          op: "falsy",          169        });          170      },          171      true(actual, message) {          172        assert(actual === true, {          173          message: message || "true",          174          actual,          175          expected: true,          176          op: "true",          177        });          178      },          179      false(actual, message) {          180        assert(actual === false, {          181          message: message || "false",          182          actual,          183          expected: false,          184          op: "false",          185        });          186      },          187      throws(fn, expectedArg, messageArg) {          188        let expected = expectedArg;          189        let message = messageArg;          190        if (typeof expectedArg === "string") {          191          expected = void 0;          192          message = expectedArg;          193        }          194          195        try {          196          fn();          197        } catch (err) {          198          if (typeof expected === "undefined") {          199            assert(true, {          200              message: message || "throws",          201              actual: err.constructor,          202              expected,          203              op: "throws",          204            });          205            return;          206          }          207          208          if (typeof expected === "function") {          209            assert(err instanceof expected, {          210              message: message || "throws",          211              actual: err.constructor,          212              expected,          213              op: "throws",          214            });          215            return;          216          }          217          218          if (expected instanceof RegExp) {          219            assert(expected.test(String(err)), {          220              message: message || "throws",          221              actual: String(err),          222              expected,          223              op: "throws",          224            });          225            return;          226          }          227          228          if (          229            Array.isArray(expected) &&          230            expected.length === 2 &&          231            expected[1] instanceof RegExp          232          ) {          233            assert(          234              err instanceof expected[0] && expected[1].test(String(err)),          235              {          236                message: message || "throws",          237                actual: [err.constructor, String(err)],          238                expected,          239                op: "throws",          240              },          241            );          242            return;          243          }          244          245          if (          246            Array.isArray(expected) &&          247            expected.length === 2 &&          248            typeof expected[1] === "string"          249          ) {          250            assert(          251              err instanceof expected[0] && expected[1] === String(err.message),          252              {          253                message: message || "throws",          254                actual: [err.constructor, String(err.message)],          255                expected,          256                op: "throws",          257              },          258            );          259            return;          260          }          261          262          assert(false, {          263            message: message || "throws",          264            op: "throws",          265            actual: err,          266            expected,          267          });          268          return;          269        }          270          271        if (typeof expected === "undefined") {          272          assert(false, {          273            message: message || "throws",          274            op: "throws",          275          });          276        } else {          277          assert(false, {          278            message: message || "throws",          279            expected,          280            op: "throws",          281          });          282        }          283      },          284      notThrows(fn, message) {          285        try {          286          fn();          287          assert(true, {          288            message: message || "notThrows",          289            op: "notThrows",          290          });          291        } catch (err) {          292          assert(false, {          293            message: message || "notThrows",          294            actual: err,          295            op: "notThrows",          296          });          297        }          298      },          299      same(actual, expected, message) {          300        assert(deepEqual(actual, expected, { strict: true }), {          301          message: message || "same",          302          actual,          303          expected,          304          op: "same",          305        });          306      },          307      notSame(actual, expected, message) {          308        assert(!deepEqual(actual, expected, { strict: true }), {          309          message: message || "notSame",          310          actual,          311          expected,          312          op: "notSame",          313        });          314      },          315      after(fn) {          316        if (typeof fn !== "function") {          317          assert(false, {          318            message: "after() argument 0 is not a function",          319            op: "after",          320          });          321          return;          322        }          323          324        afterFns.push(fn);          325      },          326      context,          327    },          328    testEnd,          329    setOnEndHandler,          330  ];   308    331}

             @@ -1,13 +1,13 @@     1       import serialize from 'serialize-access';     2       import createRunner from './runner';     3       import tapReporter from './reporter/tap';     4       import { filterError } from './stack-filter';            1import serialize from "serialize-access";            2import createRunner from "./runner";            3import tapReporter from "./reporter/tap";            4import { filterError } from "./stack-filter";     5      5     6      6const runner = createRunner();     7      7const actuallyRun = runner.run;     8      8let shouldAutorun = true;     9      9    10       runner.run = opts => {           10runner.run = (opts) => {    11     11  shouldAutorun = false;    12     12  return actuallyRun(opts);    13     13};             @@ -19,7 +19,7 @@    19     19runner.tapReporter = tapReporter;    20     20    21     21function autorun() {    22         const fn = global.setImmediate || (cb => global.setTimeout(cb, 0));           22  const fn = global.setImmediate || ((cb) => global.setTimeout(cb, 0));    23     23  let done = false;    24     24  let result = false;    25     25  fn(() => {             @@ -31,8 +31,8 @@    31     31      return;    32     32    }    33     33    34           if (global.process && typeof global.process.exit === 'function') {    35             process.on('exit', code => {           34    if (global.process && typeof global.process.exit === "function") {           35      process.on("exit", (code) => {    36     36        if (code !== 0) {    37     37          return;    38     38        }             @@ -44,7 +44,7 @@    44     44        process.exit(result ? 0 : 1);    45     45      });    46     46    47             process.on('uncaughtException', err => {           47      process.on("uncaughtException", (err) => {    48     48        console.error(filterError(err));    49     49        process.exit(1);    50     50      });             @@ -63,14 +63,17 @@    63     63    }    64     64    */    65     65    66           runner.run({    67             log: tapReporter({ log: console.log.bind(console) }),    68           }).then(ok => {    69             result = ok;    70             done = true;    71           }).catch(() => {    72             // Error being thrown earlier    73           });           66    runner           67      .run({           68        log: tapReporter({ log: console.log.bind(console) }),           69      })           70      .then((ok) => {           71        result = ok;           72        done = true;           73      })           74      .catch(() => {           75        // Error being thrown earlier           76      });    74     77  });    75     78}    76     79

             @@ -1,6 +1,6 @@     1      1/* eslint-disable no-underscore-dangle, new-cap */     2       import Promise from 'bluebird';     3       import { extractErrorStack } from './stack-filter';            2import Promise from "bluebird";            3import { extractErrorStack } from "./stack-filter";     4      4     5      5function ESTAP_TEST__(fn, t) {     6      6  return fn(t);             @@ -10,24 +10,25 @@    10     10  if (test.skip) {    11     11    ++testOpts.testsSkipped;    12     12    testOpts.log({    13             type: 'skip',           13      type: "skip",    14     14      test: test.name,    15     15    });    16     16    return Promise.resolve();    17     17  }    18     18    19         if (test.type === 'default') {           19  if (test.type === "default") {    20     20    const res = ESTAP_TEST__(test.fn, t);    21     21    22           if (Object(res) === res && typeof res.then === 'function') {    23             return res.then(() => void end())    24               .catch(e => {           22    if (Object(res) === res && typeof res.then === "function") {           23      return res           24        .then(() => void end())           25        .catch((e) => {    25     26          ++testOpts.assertionCount;    26     27          ++testOpts.assertionFailed;    27     28          testOpts.log({    28                   type: 'error',    29                   op: 'reject',    30                   message: 'promise rejection',           29            type: "error",           30            op: "reject",           31            message: "promise rejection",    31     32            actual: e,    32     33            test: test.name,    33     34            stack: extractErrorStack(e),             @@ -41,8 +42,8 @@    41     42    return Promise.resolve();    42     43  }    43     44    44         if (test.type === 'cb') {    45           return new Promise(resolve => {           45  if (test.type === "cb") {           46    return new Promise((resolve) => {    46     47      setOnEndHandler(() => {    47     48        resolve();    48     49      });             @@ -51,5 +52,5 @@    51     52    });    52     53  }    53     54    54         throw new Error('unknown test type');           55  throw new Error("unknown test type");    55     56}

             @@ -1,9 +1,9 @@     1       import Promise from 'bluebird';     2       import Map from 'es6-map';     3       import Set from 'es6-set';     4       import objectAssign from 'object-assign';     5       import runTest from './run-test';     6       import createAssert from './assert';            1import Promise from "bluebird";            2import Map from "es6-map";            3import Set from "es6-set";            4import objectAssign from "object-assign";            5import runTest from "./run-test";            6import createAssert from "./assert";     7      7     8      8export default function () {     9      9  const tests = new Map();             @@ -24,7 +24,7 @@    24     24    testData[test.role].push(test);    25     25  }    26     26    27         function createTest(unitName = '') {           27  function createTest(unitName = "") {    28     28    const test = {    29     29      name: String(unitName),    30     30    };             @@ -33,7 +33,7 @@    33     33      let name = defaultName;    34     34      let fn = null;    35     35    36             if (typeof a === 'string') {           36      if (typeof a === "string") {    37     37        name = a;    38     38        fn = b;    39     39      } else {             @@ -49,17 +49,17 @@    49     49        name,    50     50        fn,    51     51        type: opts.type,    52               role: opts.role || 'test',           52        role: opts.role || "test",    53     53        skip: opts.skip || false,    54     54        only: opts.only || false,    55     55      });    56     56    }    57     57    58           const defaultName = '(unnamed)';    59           const defaultNameBefore = 'before';    60           const defaultNameAfter = 'after';    61           const defaultNameBeforeEach = 'beforeEach';    62           const defaultNameAfterEach = 'afterEach';           58    const defaultName = "(unnamed)";           59    const defaultNameBefore = "before";           60    const defaultNameAfter = "after";           61    const defaultNameBeforeEach = "beforeEach";           62    const defaultNameAfterEach = "afterEach";    63     63    64     64    // test()    65     65    // test.only()             @@ -83,35 +83,97 @@    83     83    // test.after.skip()    84     84    // test.before.cb.skip()    85     85    // test.after.cb.skip()    86           const defineTest = (a, b) => setupTest(a, b, defaultName, { type: 'default' });    87           defineTest.only = (a, b) => setupTest(a, b, defaultName, { type: 'default', only: true });    88           defineTest.skip = (a, b) => setupTest(a, b, defaultName, { type: 'default', skip: true });    89           defineTest.cb = (a, b) => setupTest(a, b, defaultName, { type: 'cb' });    90           defineTest.cb.only = (a, b) => setupTest(a, b, defaultName, { type: 'cb', only: true });    91           defineTest.cb.skip = (a, b) => setupTest(a, b, defaultName, { type: 'cb', skip: true });    92           defineTest.beforeEach = (a, b) => setupTest(a, b, defaultNameBeforeEach, { type: 'default', role: 'beforeEach' });    93           defineTest.afterEach = (a, b) => setupTest(a, b, defaultNameAfterEach, { type: 'default', role: 'afterEach' });    94           defineTest.beforeEach.cb = (a, b) => setupTest(a, b, defaultNameBeforeEach, { type: 'cb', role: 'beforeEach' });    95           defineTest.afterEach.cb = (a, b) => setupTest(a, b, defaultNameAfterEach, { type: 'cb', role: 'afterEach' });    96           defineTest.before = (a, b) => setupTest(a, b, defaultNameBefore, { type: 'default', role: 'before' });    97           defineTest.after = (a, b) => setupTest(a, b, defaultNameAfter, { type: 'default', role: 'after' });    98           defineTest.before.cb = (a, b) => setupTest(a, b, defaultNameBefore, { type: 'cb', role: 'before' });    99           defineTest.after.cb = (a, b) => setupTest(a, b, defaultNameAfter, { type: 'cb', role: 'after' });   100           defineTest.beforeEach.skip = (a, b) => setupTest(a, b, defaultNameBeforeEach, { type: 'default', role: 'beforeEach', skip: true });   101           defineTest.afterEach.skip = (a, b) => setupTest(a, b, defaultNameAfterEach, { type: 'default', role: 'afterEach', skip: true });   102           defineTest.beforeEach.cb.skip = (a, b) => setupTest(a, b, defaultNameBeforeEach, { type: 'cb', role: 'beforeEach', skip: true });   103           defineTest.afterEach.cb.skip = (a, b) => setupTest(a, b, defaultNameAfterEach, { type: 'cb', role: 'afterEach', skip: true });   104           defineTest.before.skip = (a, b) => setupTest(a, b, defaultNameBefore, { type: 'default', role: 'before', skip: true });   105           defineTest.after.skip = (a, b) => setupTest(a, b, defaultNameAfter, { type: 'default', role: 'after', skip: true });   106           defineTest.before.cb.skip = (a, b) => setupTest(a, b, defaultNameBefore, { type: 'cb', role: 'before', skip: true });   107           defineTest.after.cb.skip = (a, b) => setupTest(a, b, defaultNameAfter, { type: 'cb', role: 'after', skip: true });           86    const defineTest = (a, b) =>           87      setupTest(a, b, defaultName, { type: "default" });           88    defineTest.only = (a, b) =>           89      setupTest(a, b, defaultName, { type: "default", only: true });           90    defineTest.skip = (a, b) =>           91      setupTest(a, b, defaultName, { type: "default", skip: true });           92    defineTest.cb = (a, b) => setupTest(a, b, defaultName, { type: "cb" });           93    defineTest.cb.only = (a, b) =>           94      setupTest(a, b, defaultName, { type: "cb", only: true });           95    defineTest.cb.skip = (a, b) =>           96      setupTest(a, b, defaultName, { type: "cb", skip: true });           97    defineTest.beforeEach = (a, b) =>           98      setupTest(a, b, defaultNameBeforeEach, {           99        type: "default",          100        role: "beforeEach",          101      });          102    defineTest.afterEach = (a, b) =>          103      setupTest(a, b, defaultNameAfterEach, {          104        type: "default",          105        role: "afterEach",          106      });          107    defineTest.beforeEach.cb = (a, b) =>          108      setupTest(a, b, defaultNameBeforeEach, {          109        type: "cb",          110        role: "beforeEach",          111      });          112    defineTest.afterEach.cb = (a, b) =>          113      setupTest(a, b, defaultNameAfterEach, { type: "cb", role: "afterEach" });          114    defineTest.before = (a, b) =>          115      setupTest(a, b, defaultNameBefore, { type: "default", role: "before" });          116    defineTest.after = (a, b) =>          117      setupTest(a, b, defaultNameAfter, { type: "default", role: "after" });          118    defineTest.before.cb = (a, b) =>          119      setupTest(a, b, defaultNameBefore, { type: "cb", role: "before" });          120    defineTest.after.cb = (a, b) =>          121      setupTest(a, b, defaultNameAfter, { type: "cb", role: "after" });          122    defineTest.beforeEach.skip = (a, b) =>          123      setupTest(a, b, defaultNameBeforeEach, {          124        type: "default",          125        role: "beforeEach",          126        skip: true,          127      });          128    defineTest.afterEach.skip = (a, b) =>          129      setupTest(a, b, defaultNameAfterEach, {          130        type: "default",          131        role: "afterEach",          132        skip: true,          133      });          134    defineTest.beforeEach.cb.skip = (a, b) =>          135      setupTest(a, b, defaultNameBeforeEach, {          136        type: "cb",          137        role: "beforeEach",          138        skip: true,          139      });          140    defineTest.afterEach.cb.skip = (a, b) =>          141      setupTest(a, b, defaultNameAfterEach, {          142        type: "cb",          143        role: "afterEach",          144        skip: true,          145      });          146    defineTest.before.skip = (a, b) =>          147      setupTest(a, b, defaultNameBefore, {          148        type: "default",          149        role: "before",          150        skip: true,          151      });          152    defineTest.after.skip = (a, b) =>          153      setupTest(a, b, defaultNameAfter, {          154        type: "default",          155        role: "after",          156        skip: true,          157      });          158    defineTest.before.cb.skip = (a, b) =>          159      setupTest(a, b, defaultNameBefore, {          160        type: "cb",          161        role: "before",          162        skip: true,          163      });          164    defineTest.after.cb.skip = (a, b) =>          165      setupTest(a, b, defaultNameAfter, {          166        type: "cb",          167        role: "after",          168        skip: true,          169      });   108    170   109    171    return defineTest;   110    172  }   111    173   112    174  createTest.run = (opts = {}) => {   113           if (typeof opts.log !== 'function') {   114             throw new Error('.log function required');          175    if (typeof opts.log !== "function") {          176      throw new Error(".log function required");   115    177    }   116    178   117    179    const testOpts = {             @@ -122,57 +184,83 @@   122    184      pendingTests: new Set(),   123    185    };   124    186   125           return Promise.map(tests.keys(), testObj => {          187    return Promise.map(tests.keys(), (testObj) => {   126    188      const testData = tests.get(testObj);   127    189   128    190      return Promise.resolve()   129               .then(() => Promise.mapSeries(testData.before, test => runTest(createAssert(test, testOpts), test, testOpts)))   130               .then(() => Promise.map(testData.test, test => {   131                 const context = {};   132                 function setupHookTest(hookTest) {   133                   return objectAssign({}, hookTest, {   134                     name: `${test.name} > ${hookTest.name}`,   135                     skip: test.skip || hookTest.skip,   136                   });   137                 }   138          139                 if (onlyTestCount > 0 && !test.only) {   140                   return Promise.resolve();   141                 }   142          143                 return Promise.resolve()   144                   .then(() => (Promise.mapSeries(testData.beforeEach, hookTest => {   145                     const updatedTest = setupHookTest(hookTest);   146                     return runTest(createAssert(updatedTest, testOpts, context), updatedTest, testOpts);   147                   })))   148                   .then(() => runTest(createAssert(test, testOpts, context), test, testOpts))   149                   .then(() => (Promise.mapSeries(testData.afterEach, hookTest => {   150                     const updatedTest = setupHookTest(hookTest);   151                     return runTest(createAssert(updatedTest, testOpts, context), updatedTest, testOpts);   152                   })));   153               }))   154               .then(() => Promise.mapSeries(testData.after, test => runTest(createAssert(test, testOpts), test, testOpts)));   155           }).then(() => {   156             const total = testOpts.assertionCount + testOpts.testsSkipped;   157             testOpts.log({   158               type: 'done',   159               count: total,   160               ok: testOpts.assertionCount - testOpts.assertionFailed,   161               error: testOpts.assertionFailed,   162               skip: testOpts.testsSkipped,   163               only: onlyTestCount,   164             });   165             if (testOpts.assertionFailed > 0 || onlyTestCount > 0) {   166               return Promise.resolve(false);   167             }   168          169             return Promise.resolve(true);   170           }).catch(err => {   171             setTimeout(() => {   172               throw err;   173             }, 0);   174             return Promise.reject();   175           });          191        .then(() =>          192          Promise.mapSeries(testData.before, (test) =>          193            runTest(createAssert(test, testOpts), test, testOpts),          194          ),          195        )          196        .then(() =>          197          Promise.map(testData.test, (test) => {          198            const context = {};          199            function setupHookTest(hookTest) {          200              return objectAssign({}, hookTest, {          201                name: `${test.name} > ${hookTest.name}`,          202                skip: test.skip || hookTest.skip,          203              });          204            }          205          206            if (onlyTestCount > 0 && !test.only) {          207              return Promise.resolve();          208            }          209          210            return Promise.resolve()          211              .then(() =>          212                Promise.mapSeries(testData.beforeEach, (hookTest) => {          213                  const updatedTest = setupHookTest(hookTest);          214                  return runTest(          215                    createAssert(updatedTest, testOpts, context),          216                    updatedTest,          217                    testOpts,          218                  );          219                }),          220              )          221              .then(() =>          222                runTest(createAssert(test, testOpts, context), test, testOpts),          223              )          224              .then(() =>          225                Promise.mapSeries(testData.afterEach, (hookTest) => {          226                  const updatedTest = setupHookTest(hookTest);          227                  return runTest(          228                    createAssert(updatedTest, testOpts, context),          229                    updatedTest,          230                    testOpts,          231                  );          232                }),          233              );          234          }),          235        )          236        .then(() =>          237          Promise.mapSeries(testData.after, (test) =>          238            runTest(createAssert(test, testOpts), test, testOpts),          239          ),          240        );          241    })          242      .then(() => {          243        const total = testOpts.assertionCount + testOpts.testsSkipped;          244        testOpts.log({          245          type: "done",          246          count: total,          247          ok: testOpts.assertionCount - testOpts.assertionFailed,          248          error: testOpts.assertionFailed,          249          skip: testOpts.testsSkipped,          250          only: onlyTestCount,          251        });          252        if (testOpts.assertionFailed > 0 || onlyTestCount > 0) {          253          return Promise.resolve(false);          254        }          255          256        return Promise.resolve(true);          257      })          258      .catch((err) => {          259        setTimeout(() => {          260          throw err;          261        }, 0);          262        return Promise.reject();          263      });   176    264  };   177    265   178    266  createTest.hasTests = () => tests.size > 0;

             @@ -1,14 +1,14 @@     1       import objectInspect from 'object-inspect';            1import objectInspect from "object-inspect";     2      2     3      3function filterImpl(stack) {     4         const lines = String(stack).split('\n');            4  const lines = String(stack).split("\n");     5      5  const filtered = [];     6      6  for (let i = 0; i < lines.length; ++i) {     7           if (lines[i].indexOf('ESTAP_TEST__') >= 0) {            7    if (lines[i].indexOf("ESTAP_TEST__") >= 0) {     8      8      break;     9      9    }    10     10    11           if (lines[i].indexOf('ESTAP_ASSERT__') >= 0) {           11    if (lines[i].indexOf("ESTAP_ASSERT__") >= 0) {    12     12      i++;    13     13      continue;    14     14    }             @@ -21,7 +21,7 @@    21     21    22     22export function filterError(err) {    23     23  if (err instanceof Error) {    24           return filterImpl(err.stack).join('\n');           24    return filterImpl(err.stack).join("\n");    25     25  }    26     26    27     27  return `Uncaught exception: ${objectInspect(err)}`;             @@ -29,7 +29,9 @@    29     29    30     30export function extractErrorStack(err) {    31     31  if (err instanceof Error) {    32           return filterImpl(err.stack).map(s => s.trim()).slice(1);           32    return filterImpl(err.stack)           33      .map((s) => s.trim())           34      .slice(1);    33     35  }    34     36    35     37  return [];

             @@ -1,11 +1,12 @@     1      1export default function ({ log }) {     2         return obj => {     3           if (obj.type === 'error') {     4             log(JSON.stringify(obj, null, 2)     5               .replace(/"(actual)":/gm, '"$1"  :')     6               .replace(/"(op)":/gm, '"$1"      :')     7               .replace(/"(type)":/gm, '"$1"    :')     8               .replace(/"(message)":/gm, '"$1" :')            2  return (obj) => {            3    if (obj.type === "error") {            4      log(            5        JSON.stringify(obj, null, 2)            6          .replace(/"(actual)":/gm, '"$1"  :')            7          .replace(/"(op)":/gm, '"$1"      :')            8          .replace(/"(type)":/gm, '"$1"    :')            9          .replace(/"(message)":/gm, '"$1" :'),     9     10      );    10     11      return;    11     12    }

             @@ -1,8 +1,8 @@     1       import YAML from 'yamljs';     2       import objectInspect from 'object-inspect';            1import YAML from "yamljs";            2import objectInspect from "object-inspect";     3      3     4      4function inspect(obj) {     5         if (typeof obj === 'string') {            5  if (typeof obj === "string") {     6      6    return `(string) ${obj}`;     7      7  }     8      8             @@ -11,61 +11,63 @@    11     11    12     12export default function ({ log }) {    13     13  let assertionCount = 0;    14         log('TAP version 13');    15           16         return obj => {    17           if (obj.type === 'ok') {           14  log("TAP version 13");           15           16  return (obj) => {           17    if (obj.type === "ok") {    18     18      log(`ok ${++assertionCount} ${obj.test} > ${obj.message}`);    19     19      return;    20     20    }    21     21    22           if (obj.type === 'error') {           22    if (obj.type === "error") {    23     23      log(`not ok ${++assertionCount} ${obj.test} > ${obj.message}`);    24             log('  ---');           24      log("  ---");    25     25    26     26      const yamlData = {};    27     27    28             if ({}.hasOwnProperty.call(obj, 'op')) {           28      if ({}.hasOwnProperty.call(obj, "op")) {    29     29        yamlData.op = obj.op;    30     30      }    31     31    32             if ({}.hasOwnProperty.call(obj, 'actual')) {           32      if ({}.hasOwnProperty.call(obj, "actual")) {    33     33        yamlData.actual = inspect(obj.actual);    34     34      }    35     35    36             if ({}.hasOwnProperty.call(obj, 'expected')) {           36      if ({}.hasOwnProperty.call(obj, "expected")) {    37     37        yamlData.expected = inspect(obj.expected);    38     38      }    39     39    40             if ({}.hasOwnProperty.call(obj, 'stack') && obj.stack.length > 0) {           40      if ({}.hasOwnProperty.call(obj, "stack") && obj.stack.length > 0) {    41     41        yamlData.stack = obj.stack;    42     42      }    43     43    44     44      const yaml = YAML.stringify(yamlData, 2, 2)    45               .replace(/^actual:\s/m, 'actual:   ')    46               .replace(/^op:\s/m, 'op:       ')    47               .replace(/^at:\s/m, 'at:       ')    48               .split('\n')           45        .replace(/^actual:\s/m, "actual:   ")           46        .replace(/^op:\s/m, "op:       ")           47        .replace(/^at:\s/m, "at:       ")           48        .split("\n")    49     49        .slice(0, -1)    50               .map(v => `    ${v}`)    51               .join('\n');           50        .map((v) => `    ${v}`)           51        .join("\n");    52     52    53     53      log(yaml);    54             log('  ...');    55             return;    56           }    57           58           if (obj.type === 'done') {    59             log('');           54      log("  ...");           55      return;           56    }           57           58    if (obj.type === "done") {           59      log("");    60     60      log(`1..${assertionCount}`);    61     61    62     62      if (obj.error > 0) {    63     63        if (obj.skip > 0) {    64                 log(`# passing ${obj.ok}/${obj.count} (${obj.error} failing, ${obj.skip} skipping)`);           64          log(           65            `# passing ${obj.ok}/${obj.count} (${obj.error} failing, ${obj.skip} skipping)`,           66          );    65     67        } else {    66     68          log(`# passing ${obj.ok}/${obj.count} (${obj.error} failing)`);    67     69        }    68               log('# fail');           70        log("# fail");    69     71      } else {    70     72        if (obj.skip > 0) {    71     73          log(`# passing ${obj.ok}/${obj.count} (${obj.skip} skipping)`);             @@ -74,9 +76,9 @@    74     76        }    75     77    76     78        if (obj.only) {    77                 log('# ok (but not running all the tests)');    78               } else {    79                 log('# ok');           79          log("# ok (but not running all the tests)");           80        } else {           81          log("# ok");    80     82        }    81     83      }    82     84      return;

             @@ -2,41 +2,46 @@     2      2  const logs = [];     3      3  let finished = false;     4      4     5         return obj => {            5  return (obj) => {     6      6    if (finished) {     7             throw new Error('unexpected log output');     8           }     9           10           if (obj.type === 'error') {            7      throw new Error("unexpected log output");            8    }            9           10    if (obj.type === "error") {    11     11      let skip = false;    12             obj.stack = obj.stack.map(v => {    13               if (skip) {    14                 return null;    15               }    16           17               if (v.indexOf('timers.js') >= 0) {    18                 return null;    19               }    20           21               if (v.indexOf('bluebird') >= 0) {    22                 return null;    23               }    24           25               if (v.indexOf('http://localhost') >= 0) {    26                 return 'at <test>';    27               }    28           29               if (v.indexOf('From previous event:') >= 0) {    30                 skip = true;    31                 return null;    32               }    33           34               return v.replace(/at\s(.+)\/test\/unit\/[a-z-]+\.js:\d+:\d+\)?/, 'at <test>');    35             }).filter(Boolean);           12      obj.stack = obj.stack           13        .map((v) => {           14          if (skip) {           15            return null;           16          }           17           18          if (v.indexOf("timers.js") >= 0) {           19            return null;           20          }           21           22          if (v.indexOf("bluebird") >= 0) {           23            return null;           24          }           25           26          if (v.indexOf("http://localhost") >= 0) {           27            return "at <test>";           28          }           29           30          if (v.indexOf("From previous event:") >= 0) {           31            skip = true;           32            return null;           33          }           34           35          return v.replace(           36            /at\s(.+)\/test\/unit\/[a-z-]+\.js:\d+:\d+\)?/,           37            "at <test>",           38          );           39        })           40        .filter(Boolean);    36     41    }    37     42    38     43    logs.push(obj);    39           if (obj.type === 'done') {           44    if (obj.type === "done") {    40     45      finished = true;    41     46      done(logs);    42     47      return;

             @@ -1,4 +1,4 @@     1      1// bluebird doesn't work without setImmediate in node     2       import 'bluebird';            2import "bluebird";     3      3     4      4global.setImmediate = void 0;

             @@ -1,25 +1,30 @@     1       import test from 'tape';     2       import estap from '../../lib';     3       import collectLogs from './collect-logs';            1import test from "tape";            2import estap from "../../lib";            3import collectLogs from "./collect-logs";     4      4     5      5export default function (name, fn, out, result, opts = {}) {     6      6  const def = opts.only ? test.only.bind(test) : test;     7         def(name, assert => {            7  def(name, (assert) => {     8      8    assert.plan(2);     9      9    const runner = estap.createRunner();    10     10    11     11    fn(runner, assert);    12     12    13           runner.run({    14             log: collectLogs(logs => {    15               assert.same(logs, out, 'output');    16             }),    17           })    18           .then(res => {    19             assert.is(res, result, result ? 'test result true' : 'test result false');    20           })    21           .catch(() => {    22             assert.is(result, null, 'test result error');    23           });           13    runner           14      .run({           15        log: collectLogs((logs) => {           16          assert.same(logs, out, "output");           17        }),           18      })           19      .then((res) => {           20        assert.is(           21          res,           22          result,           23          result ? "test result true" : "test result false",           24        );           25      })           26      .catch(() => {           27        assert.is(result, null, "test result error");           28      });    24     29  });    25     30}

             @@ -6,5 +6,5 @@     6      6    };     7      7  }     8      8     9         process.once('uncaughtException', fn);            9  process.once("uncaughtException", fn);    10     10}

             @@ -1,13 +1,13 @@     1      1/* eslint-disable no-unreachable */     2       import estap from '../../lib';            2import estap from "../../lib";     3      3     4      4const test = estap();     5      5     6       test.cb('check some numbers', t => {            6test.cb("check some numbers", (t) => {     7      7  setTimeout(() => {     8      8    t.end();     9      9  }, 1);    10     10  t.is(10, 10);    11         throw new Error('this is an error');           11  throw new Error("this is an error");    12     12  t.is(10 + 11, 20);    13     13});

             @@ -1,8 +1,8 @@     1       import estap from '../../lib';            1import estap from "../../lib";     2      2     3      3const test = estap();     4      4     5       test.cb('check some numbers', t => {            5test.cb("check some numbers", (t) => {     6      6  setTimeout(() => {     7      7    t.is(10, 10);     8      8    t.is(10 + 11, 20);

             @@ -1,8 +1,8 @@     1       import estap from '../../lib';            1import estap from "../../lib";     2      2     3      3const test = estap();     4      4     5       test.cb('check some numbers', t => {            5test.cb("check some numbers", (t) => {     6      6  setTimeout(() => {     7      7    t.is(10, 10);     8      8    t.is(10 + 10, 20);

             @@ -1,9 +1,9 @@     1      1/* eslint-disable no-throw-literal, no-unreachable */     2       import estap from '../../lib';            2import estap from "../../lib";     3      3     4      4const test = estap();     5      5     6       test.cb('check some numbers', t => {            6test.cb("check some numbers", (t) => {     7      7  setTimeout(() => {     8      8    t.end();     9      9  }, 1);

             @@ -1,62 +1,81 @@     1       import { execFile } from 'child_process';     2       import path from 'path';     3       import test from 'tape';     4            5       const babelNode = path.resolve(__dirname, '../../node_modules/babel-cli/bin/babel-node.js');            1import { execFile } from "child_process";            2import path from "path";            3import test from "tape";            4            5const babelNode = path.resolve(            6  __dirname,            7  "../../node_modules/babel-cli/bin/babel-node.js",            8);     6      9     7     10function execTest(fileName, fn) {     8     11  function fixOutput(s) {     9           if (s === '') {           12    if (s === "") {    10     13      return s;    11     14    }    12     15    13           return '\n' + s.split('\n').map(l => {    14             if (l.indexOf('      - \'at ') === 0) {    15               if (l.indexOf(fileName) >= 0) {    16                 return '      - \'at <testcallsite>\'';    17               }    18           19               return '      - \'at <callsite>\'';    20             }    21           22             if (l.indexOf('    at ') === 0) {    23               if (l.indexOf(fileName) >= 0) {    24                 return '    at <testcallsite>';    25               }    26           27               return '    at <callsite>';    28             }    29           30             return l;    31           }).join('\n');           16    return (           17      "\n" +           18      s           19        .split("\n")           20        .map((l) => {           21          if (l.indexOf("      - 'at ") === 0) {           22            if (l.indexOf(fileName) >= 0) {           23              return "      - 'at <testcallsite>'";           24            }           25           26            return "      - 'at <callsite>'";           27          }           28           29          if (l.indexOf("    at ") === 0) {           30            if (l.indexOf(fileName) >= 0) {           31              return "    at <testcallsite>";           32            }           33           34            return "    at <callsite>";           35          }           36           37          return l;           38        })           39        .join("\n")           40    );    32     41  }    33         test(fileName, t => {    34           execFile(babelNode, [path.resolve(__dirname, `${fileName}`)], (err, stdout, stderr) => {    35             const out = fixOutput(stdout);    36             const outErr = fixOutput(stderr);    37             fn(t, err, out, outErr);    38           });           42  test(fileName, (t) => {           43    execFile(           44      babelNode,           45      [path.resolve(__dirname, `${fileName}`)],           46      (err, stdout, stderr) => {           47        const out = fixOutput(stdout);           48        const outErr = fixOutput(stderr);           49        fn(t, err, out, outErr);           50      },           51    );    39     52  });    40     53}    41     54    42       execTest('cb-ok.js', (t, err, stdout, stderr) => {    43         t.error(err, 'ok');    44         t.is(stdout, `    45       TAP version 13    46       ok 1 check some numbers > is    47       ok 2 check some numbers > is    48           49       1..2    50       # passing 2/2    51       # ok    52       `, 'stdout');    53         t.is(stderr, '', 'stderr');    54         t.end();    55       });    56           57       execTest('cb-fail.js', (t, err, stdout, stderr) => {    58         t.ok(err, 'errored');    59         t.is(stdout, `           55execTest("cb-ok.js", (t, err, stdout, stderr) => {           56  t.error(err, "ok");           57  t.is(           58    stdout,           59    `           60TAP version 13           61ok 1 check some numbers > is           62ok 2 check some numbers > is           63           641..2           65# passing 2/2           66# ok           67`,           68    "stdout",           69  );           70  t.is(stderr, "", "stderr");           71  t.end();           72});           73           74execTest("cb-fail.js", (t, err, stdout, stderr) => {           75  t.ok(err, "errored");           76  t.is(           77    stdout,           78    `    60     79TAP version 13    61     80ok 1 check some numbers > is    62     81not ok 2 check some numbers > is             @@ -72,54 +91,78 @@    72     911..2    73     92# passing 1/2 (1 failing)    74     93# fail    75       `, 'stdout');    76         t.is(stderr, '', 'stderr');    77         t.end();    78       });    79           80       execTest('cb-error.js', (t, err, stdout, stderr) => {    81         t.ok(err, 'errored');    82         t.is(stdout, `    83       TAP version 13    84       ok 1 check some numbers > is    85       `, 'stdout');    86         t.is(stderr, `           94`,           95    "stdout",           96  );           97  t.is(stderr, "", "stderr");           98  t.end();           99});          100          101execTest("cb-error.js", (t, err, stdout, stderr) => {          102  t.ok(err, "errored");          103  t.is(          104    stdout,          105    `          106TAP version 13          107ok 1 check some numbers > is          108`,          109    "stdout",          110  );          111  t.is(          112    stderr,          113    `    87    114Error: this is an error    88    115    at <testcallsite>    89       `, 'stderr');    90         t.end();    91       });    92           93       execTest('cb-throw-nonerror.js', (t, err, stdout, stderr) => {    94         t.ok(err, 'errored');    95         t.is(stdout, `    96       TAP version 13    97       ok 1 check some numbers > is    98       `, 'stdout');    99         t.is(stderr, `          116`,          117    "stderr",          118  );          119  t.end();          120});          121          122execTest("cb-throw-nonerror.js", (t, err, stdout, stderr) => {          123  t.ok(err, "errored");          124  t.is(          125    stdout,          126    `          127TAP version 13          128ok 1 check some numbers > is          129`,          130    "stdout",          131  );          132  t.is(          133    stderr,          134    `   100    135Uncaught exception: 1   101       `, 'stderr');   102         t.end();   103       });   104          105       execTest('sync-ok.js', (t, err, stdout, stderr) => {   106         t.error(err, 'ok');   107         t.is(stdout, `   108       TAP version 13   109       ok 1 check some numbers > is   110       ok 2 check some numbers > is   111          112       1..2   113       # passing 2/2   114       # ok   115       `, 'stdout');   116         t.is(stderr, '', 'stderr');   117         t.end();   118       });   119          120       execTest('sync-fail.js', (t, err, stdout, stderr) => {   121         t.ok(err, 'errored');   122         t.is(stdout, `          136`,          137    "stderr",          138  );          139  t.end();          140});          141          142execTest("sync-ok.js", (t, err, stdout, stderr) => {          143  t.error(err, "ok");          144  t.is(          145    stdout,          146    `          147TAP version 13          148ok 1 check some numbers > is          149ok 2 check some numbers > is          150          1511..2          152# passing 2/2          153# ok          154`,          155    "stdout",          156  );          157  t.is(stderr, "", "stderr");          158  t.end();          159});          160          161execTest("sync-fail.js", (t, err, stdout, stderr) => {          162  t.ok(err, "errored");          163  t.is(          164    stdout,          165    `   123    166TAP version 13   124    167ok 1 check some numbers > is   125    168not ok 2 check some numbers > is             @@ -134,27 +177,39 @@   134    1771..2   135    178# passing 1/2 (1 failing)   136    179# fail   137       `, 'stdout');   138         t.is(stderr, '', 'stderr');   139         t.end();   140       });   141          142       execTest('sync-error.js', (t, err, stdout, stderr) => {   143         t.ok(err, 'errored');   144         t.is(stdout, `   145       TAP version 13   146       ok 1 check some numbers > is   147       `, 'stdout');   148         t.is(stderr, `          180`,          181    "stdout",          182  );          183  t.is(stderr, "", "stderr");          184  t.end();          185});          186          187execTest("sync-error.js", (t, err, stdout, stderr) => {          188  t.ok(err, "errored");          189  t.is(          190    stdout,          191    `          192TAP version 13          193ok 1 check some numbers > is          194`,          195    "stdout",          196  );          197  t.is(          198    stderr,          199    `   149    200ReferenceError: thisIsAnError is not defined   150    201    at <testcallsite>   151       `, 'stderr');   152         t.end();   153       });   154          155       execTest('promise-ok.js', (t, err, stdout, stderr) => {   156         t.error(err, 'ok');   157         t.is(stdout, `          202`,          203    "stderr",          204  );          205  t.end();          206});          207          208execTest("promise-ok.js", (t, err, stdout, stderr) => {          209  t.error(err, "ok");          210  t.is(          211    stdout,          212    `   158    213TAP version 13   159    214ok 1 check some numbers > is   160    215             @@ -161,14 +216,18 @@   161    2161..1   162    217# passing 1/1   163    218# ok   164       `, 'stdout');   165         t.is(stderr, '', 'stderr');   166         t.end();   167       });   168          169       execTest('promise-fail.js', (t, err, stdout, stderr) => {   170         t.ok(err, 'errored');   171         t.is(stdout, `          219`,          220    "stdout",          221  );          222  t.is(stderr, "", "stderr");          223  t.end();          224});          225          226execTest("promise-fail.js", (t, err, stdout, stderr) => {          227  t.ok(err, "errored");          228  t.is(          229    stdout,          230    `   172    231TAP version 13   173    232ok 1 check some numbers > is   174    233not ok 2 check some numbers > promise rejection             @@ -180,14 +239,18 @@   180    2391..2   181    240# passing 1/2 (1 failing)   182    241# fail   183       `, 'stdout');   184         t.is(stderr, '', 'stderr');   185         t.end();   186       });   187          188       execTest('promise-error.js', (t, err, stdout, stderr) => {   189         t.ok(err, 'errored');   190         t.is(stdout, `          242`,          243    "stdout",          244  );          245  t.is(stderr, "", "stderr");          246  t.end();          247});          248          249execTest("promise-error.js", (t, err, stdout, stderr) => {          250  t.ok(err, "errored");          251  t.is(          252    stdout,          253    `   191    254TAP version 13   192    255ok 1 check some numbers > is   193    256not ok 2 check some numbers > promise rejection             @@ -203,56 +266,72 @@   203    2661..2   204    267# passing 1/2 (1 failing)   205    268# fail   206       `, 'stdout');   207         t.is(stderr, '', 'stderr');   208         t.end();   209       });   210          211       execTest('no-set-immediate.js', (t, err, stdout, stderr) => {   212         t.error(err, 'ok');   213         t.is(stdout, `   214       TAP version 13   215       ok 1 check some numbers > is   216       ok 2 check some numbers > is   217          218       1..2   219       # passing 2/2   220       # ok   221       `, 'stdout');   222         t.is(stderr, '', 'stderr');   223         t.end();   224       });   225          226       execTest('no-autorun.js', (t, err, stdout, stderr) => {   227         t.error(err, 'ok');   228         t.is(stdout, '', 'stdout');   229         t.is(stderr, '', 'stderr');   230         t.end();   231       });   232          233       execTest('manual-run.js', (t, err, stdout, stderr) => {   234         t.error(err, 'ok');   235         t.is(stdout, `   236       { type: 'ok', test: 'should pass', message: 'pass' }   237       { type: 'done', count: 1, ok: 1, error: 0, skip: 0, only: 0 }   238       `, 'stdout');   239         t.is(stderr, '', 'stderr');   240         t.end();   241       });   242          243       execTest('manual-run-delay.js', (t, err, stdout, stderr) => {   244         t.error(err, 'ok');   245         t.is(stdout, `   246       { type: 'ok', test: 'should pass', message: 'pass' }   247       { type: 'done', count: 1, ok: 1, error: 0, skip: 0, only: 0 }   248       `, 'stdout');   249         t.is(stderr, '', 'stderr');   250         t.end();   251       });   252          253       execTest('no-process-exit.js', (t, err, stdout, stderr) => {   254         t.error(err, 'no error despite test failure');   255         t.is(stdout, `          269`,          270    "stdout",          271  );          272  t.is(stderr, "", "stderr");          273  t.end();          274});          275          276execTest("no-set-immediate.js", (t, err, stdout, stderr) => {          277  t.error(err, "ok");          278  t.is(          279    stdout,          280    `          281TAP version 13          282ok 1 check some numbers > is          283ok 2 check some numbers > is          284          2851..2          286# passing 2/2          287# ok          288`,          289    "stdout",          290  );          291  t.is(stderr, "", "stderr");          292  t.end();          293});          294          295execTest("no-autorun.js", (t, err, stdout, stderr) => {          296  t.error(err, "ok");          297  t.is(stdout, "", "stdout");          298  t.is(stderr, "", "stderr");          299  t.end();          300});          301          302execTest("manual-run.js", (t, err, stdout, stderr) => {          303  t.error(err, "ok");          304  t.is(          305    stdout,          306    `          307{ type: 'ok', test: 'should pass', message: 'pass' }          308{ type: 'done', count: 1, ok: 1, error: 0, skip: 0, only: 0 }          309`,          310    "stdout",          311  );          312  t.is(stderr, "", "stderr");          313  t.end();          314});          315          316execTest("manual-run-delay.js", (t, err, stdout, stderr) => {          317  t.error(err, "ok");          318  t.is(          319    stdout,          320    `          321{ type: 'ok', test: 'should pass', message: 'pass' }          322{ type: 'done', count: 1, ok: 1, error: 0, skip: 0, only: 0 }          323`,          324    "stdout",          325  );          326  t.is(stderr, "", "stderr");          327  t.end();          328});          329          330execTest("no-process-exit.js", (t, err, stdout, stderr) => {          331  t.error(err, "no error despite test failure");          332  t.is(          333    stdout,          334    `   256    335TAP version 13   257    336not ok 1 should pass > fail   258    337  ---             @@ -266,83 +345,107 @@   266    3451..1   267    346# passing 0/1 (1 failing)   268    347# fail   269       `, 'stdout');   270         t.is(stderr, '', 'stderr');   271         t.end();   272       });   273          274       execTest('plan-ok.js', (t, err, stdout, stderr) => {   275         t.error(err, 'ok');   276         t.is(stdout, `   277       TAP version 13   278       ok 1 should pass > timeout 1   279       ok 2 should pass > timeout 2   280          281       1..2   282       # passing 2/2   283       # ok   284       `, 'stdout');   285         t.is(stderr, '', 'stderr');   286         t.end();   287       });   288          289       execTest('plan-gt-expected.js', (t, err, stdout, stderr) => {   290         t.ok(err, 'errored');   291         t.is(stdout, `   292       TAP version 13   293       ok 1 should pass > timeout 1   294       ok 2 should pass > timeout 2   295          296       1..2   297       # passing 2/2   298       # ok   299       `, 'stdout');   300         t.is(stderr, `          348`,          349    "stdout",          350  );          351  t.is(stderr, "", "stderr");          352  t.end();          353});          354          355execTest("plan-ok.js", (t, err, stdout, stderr) => {          356  t.error(err, "ok");          357  t.is(          358    stdout,          359    `          360TAP version 13          361ok 1 should pass > timeout 1          362ok 2 should pass > timeout 2          363          3641..2          365# passing 2/2          366# ok          367`,          368    "stdout",          369  );          370  t.is(stderr, "", "stderr");          371  t.end();          372});          373          374execTest("plan-gt-expected.js", (t, err, stdout, stderr) => {          375  t.ok(err, "errored");          376  t.is(          377    stdout,          378    `          379TAP version 13          380ok 1 should pass > timeout 1          381ok 2 should pass > timeout 2          382          3831..2          384# passing 2/2          385# ok          386`,          387    "stdout",          388  );          389  t.is(          390    stderr,          391    `   301    392Error: assertion after end   302    393    at <testcallsite>   303    394    at <callsite>   304       `, 'stderr');   305         t.end();   306       });   307          308       execTest('plan-sync-ok.js', (t, err, stdout, stderr) => {   309         t.error(err, 'ok');   310         t.is(stdout, `   311       TAP version 13   312       ok 1 should pass > 1   313       ok 2 should pass > 2   314          315       1..2   316       # passing 2/2   317       # ok   318       `, 'stdout');   319         t.is(stderr, '', 'stderr');   320         t.end();   321       });   322          323       execTest('plan-sync-lt.js', (t, err, stdout, stderr) => {   324         t.ok(err, 'errored');   325         t.is(stdout, `   326       TAP version 13   327       ok 1 should pass > 1   328       not ok 2 should pass > assertions count does not match plan   329         ---   330           op:       plan   331           actual:   '(number) 1'   332           expected: '(number) 2'   333         ...   334          335       1..2   336       # passing 1/2 (1 failing)   337       # fail   338       `, 'stdout');   339         t.is(stderr, '', 'stderr');   340         t.end();   341       });   342          343       execTest('plan-sync-gt.js', (t, err, stdout, stderr) => {   344         t.ok(err, 'errored');   345         t.is(stdout, `          395`,          396    "stderr",          397  );          398  t.end();          399});          400          401execTest("plan-sync-ok.js", (t, err, stdout, stderr) => {          402  t.error(err, "ok");          403  t.is(          404    stdout,          405    `          406TAP version 13          407ok 1 should pass > 1          408ok 2 should pass > 2          409          4101..2          411# passing 2/2          412# ok          413`,          414    "stdout",          415  );          416  t.is(stderr, "", "stderr");          417  t.end();          418});          419          420execTest("plan-sync-lt.js", (t, err, stdout, stderr) => {          421  t.ok(err, "errored");          422  t.is(          423    stdout,          424    `          425TAP version 13          426ok 1 should pass > 1          427not ok 2 should pass > assertions count does not match plan          428  ---          429    op:       plan          430    actual:   '(number) 1'          431    expected: '(number) 2'          432  ...          433          4341..2          435# passing 1/2 (1 failing)          436# fail          437`,          438    "stdout",          439  );          440  t.is(stderr, "", "stderr");          441  t.end();          442});          443          444execTest("plan-sync-gt.js", (t, err, stdout, stderr) => {          445  t.ok(err, "errored");          446  t.is(          447    stdout,          448    `   346    449TAP version 13   347    450ok 1 should pass > 1   348    451ok 2 should pass > 2             @@ -357,49 +460,61 @@   357    4601..4   358    461# passing 3/4 (1 failing)   359    462# fail   360       `, 'stdout');   361         t.is(stderr, '', 'stderr');   362         t.end();   363       });   364          365       execTest('plan-promise-ok.js', (t, err, stdout, stderr) => {   366         t.error(err, 'ok');   367         t.is(stdout, `   368       TAP version 13   369       ok 1 should pass > pass   370       ok 2 should pass > pass   371          372       1..2   373       # passing 2/2   374       # ok   375       `, 'stdout');   376         t.is(stderr, '', 'stderr');   377         t.end();   378       });   379          380       execTest('plan-promise-lt.js', (t, err, stdout, stderr) => {   381         t.ok(err, 'errored');   382         t.is(stdout, `   383       TAP version 13   384       ok 1 should pass > pass   385       not ok 2 should pass > assertions count does not match plan   386         ---   387           op:       plan   388           actual:   '(number) 1'   389           expected: '(number) 2'   390         ...   391          392       1..2   393       # passing 1/2 (1 failing)   394       # fail   395       `, 'stdout');   396         t.is(stderr, '', 'stderr');   397         t.end();   398       });   399          400       execTest('plan-promise-gt.js', (t, err, stdout, stderr) => {   401         t.ok(err, 'errored');   402         t.is(stdout, `          463`,          464    "stdout",          465  );          466  t.is(stderr, "", "stderr");          467  t.end();          468});          469          470execTest("plan-promise-ok.js", (t, err, stdout, stderr) => {          471  t.error(err, "ok");          472  t.is(          473    stdout,          474    `          475TAP version 13          476ok 1 should pass > pass          477ok 2 should pass > pass          478          4791..2          480# passing 2/2          481# ok          482`,          483    "stdout",          484  );          485  t.is(stderr, "", "stderr");          486  t.end();          487});          488          489execTest("plan-promise-lt.js", (t, err, stdout, stderr) => {          490  t.ok(err, "errored");          491  t.is(          492    stdout,          493    `          494TAP version 13          495ok 1 should pass > pass          496not ok 2 should pass > assertions count does not match plan          497  ---          498    op:       plan          499    actual:   '(number) 1'          500    expected: '(number) 2'          501  ...          502          5031..2          504# passing 1/2 (1 failing)          505# fail          506`,          507    "stdout",          508  );          509  t.is(stderr, "", "stderr");          510  t.end();          511});          512          513execTest("plan-promise-gt.js", (t, err, stdout, stderr) => {          514  t.ok(err, "errored");          515  t.is(          516    stdout,          517    `   403    518TAP version 13   404    519ok 1 should pass > pass   405    520ok 2 should pass > pass             @@ -413,24 +528,32 @@   413    5281..3   414    529# passing 2/3 (1 failing)   415    530# fail   416       `, 'stdout');   417         t.is(stderr, '', 'stderr');   418         t.end();   419       });   420          421       execTest('process-exit.js', (t, err, stdout, stderr) => {   422         t.ok(err, 'errored');   423         t.is(stdout, `   424       TAP version 13   425       ok 1 should pass > pass   426       `, 'stdout');   427         t.is(stderr, '', 'stderr');   428         t.end();   429       });   430          431       execTest('throws-ok.js', (t, err, stdout, stderr) => {   432         t.error(err, 'ok');   433         t.is(stdout, `          531`,          532    "stdout",          533  );          534  t.is(stderr, "", "stderr");          535  t.end();          536});          537          538execTest("process-exit.js", (t, err, stdout, stderr) => {          539  t.ok(err, "errored");          540  t.is(          541    stdout,          542    `          543TAP version 13          544ok 1 should pass > pass          545`,          546    "stdout",          547  );          548  t.is(stderr, "", "stderr");          549  t.end();          550});          551          552execTest("throws-ok.js", (t, err, stdout, stderr) => {          553  t.error(err, "ok");          554  t.is(          555    stdout,          556    `   434    557TAP version 13   435    558ok 1 throws/notThrows > throws   436    559ok 2 throws/notThrows > throws             @@ -444,14 +567,18 @@   444    5671..8   445    568# passing 8/8   446    569# ok   447       `, 'stdout');   448         t.is(stderr, '', 'stderr');   449         t.end();   450       });   451          452       execTest('throws-error.js', (t, err, stdout, stderr) => {   453         t.ok(err, 'errored');   454         t.is(stdout, `          570`,          571    "stdout",          572  );          573  t.is(stderr, "", "stderr");          574  t.end();          575});          576          577execTest("throws-error.js", (t, err, stdout, stderr) => {          578  t.ok(err, "errored");          579  t.is(          580    stdout,          581    `   455    582TAP version 13   456    583not ok 1 throws/notThrows > throws   457    584  ---             @@ -516,7 +643,9 @@   516    6431..8   517    644# passing 0/8 (8 failing)   518    645# fail   519       `, 'stdout');   520         t.is(stderr, '', 'stderr');          646`,          647    "stdout",          648  );          649  t.is(stderr, "", "stderr");   521    650  t.end();   522    651});