Reformat all files with prettier

       1 line hidden  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}

       1 line hidden  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```
       88 lines hidden117 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 line hidden

  1    import estap from '../lib';      1import estap from "../lib";  2   2  3   3const test = estap();  4   4       1 line hidden  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    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    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) {       5 lines hidden 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  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,       7 lines hidden 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  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    }       2 lines hidden 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       1 line hidden 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    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};       5 lines hidden 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(() => {       5 lines hidden 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        }       5 lines hidden 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      });       12 lines hidden 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       3 lines hidden

  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);       3 lines hidden 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),       7 lines hidden 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      });       2 lines hidden 51  52    }); 52  53  } 53  54 54      throw new Error('unknown test type');     55  throw new Error("unknown test type"); 55  56}

  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();       14 lines hidden 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    };       2 lines hidden 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 {       9 lines hidden 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()       17 lines hidden 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 170109 171    return defineTest;110 172  }111 173112 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 178117 179    const testOpts = {       4 lines hidden122 184      pendingTests: new Set(),123 185    };124 186125        return Promise.map(tests.keys(), testObj => {    187    return Promise.map(tests.keys(), (testObj) => {126 188      const testData = tests.get(testObj);127 189128 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 265178 266  createTest.hasTests = () => tests.size > 0;       3 lines hidden

  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    }       6 lines hidden 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)}`;       1 line hidden 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 line hidden

  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    }       4 lines hidden

  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       2 lines hidden 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)`);       2 lines hidden 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;       3 lines hidden

       1 line hidden  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;       3 lines hidden

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

  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}

       5 lines hidden  6   6    };  7   7  }  8   8  9      process.once('uncaughtException', fn);      9  process.once("uncaughtException", fn); 10  10}

  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    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);       3 lines hidden

  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);       3 lines hidden

  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);       4 lines hidden

  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       9 lines hidden 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: 1101    `, '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 13109    ok 1 check some numbers > is110    ok 2 check some numbers > is111    112    1..2113    # passing 2/2114    # ok115    `, '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 13124 167ok 1 check some numbers > is125 168not ok 2 check some numbers > is       8 lines hidden134 1771..2135 178# passing 1/2 (1 failing)136 179# fail137    `, '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 13146    ok 1 check some numbers > is147    `, '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 defined150 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 13159 214ok 1 check some numbers > is160 215161 2161..1162 217# passing 1/1163 218# ok164    `, '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 13173 232ok 1 check some numbers > is174 233not ok 2 check some numbers > promise rejection       5 lines hidden180 2391..2181 240# passing 1/2 (1 failing)182 241# fail183    `, '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 13192 255ok 1 check some numbers > is193 256not ok 2 check some numbers > promise rejection       9 lines hidden203 2661..2204 267# passing 1/2 (1 failing)205 268# fail206    `, '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 13215    ok 1 check some numbers > is216    ok 2 check some numbers > is217    218    1..2219    # passing 2/2220    # ok221    `, '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 13257 336not ok 1 should pass > fail258 337  ---       7 lines hidden266 3451..1267 346# passing 0/1 (1 failing)268 347# fail269    `, '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 13278    ok 1 should pass > timeout 1279    ok 2 should pass > timeout 2280    281    1..2282    # passing 2/2283    # ok284    `, '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 13293    ok 1 should pass > timeout 1294    ok 2 should pass > timeout 2295    296    1..2297    # passing 2/2298    # ok299    `, '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 end302 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 13312    ok 1 should pass > 1313    ok 2 should pass > 2314    315    1..2316    # passing 2/2317    # ok318    `, '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 13327    ok 1 should pass > 1328    not ok 2 should pass > assertions count does not match plan329      ---330        op:       plan331        actual:   '(number) 1'332        expected: '(number) 2'333      ...334    335    1..2336    # passing 1/2 (1 failing)337    # fail338    `, '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 13347 450ok 1 should pass > 1348 451ok 2 should pass > 2       8 lines hidden357 4601..4358 461# passing 3/4 (1 failing)359 462# fail360    `, '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 13369    ok 1 should pass > pass370    ok 2 should pass > pass371    372    1..2373    # passing 2/2374    # ok375    `, '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 13384    ok 1 should pass > pass385    not ok 2 should pass > assertions count does not match plan386      ---387        op:       plan388        actual:   '(number) 1'389        expected: '(number) 2'390      ...391    392    1..2393    # passing 1/2 (1 failing)394    # fail395    `, '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 13404 519ok 1 should pass > pass405 520ok 2 should pass > pass       7 lines hidden413 5281..3414 529# passing 2/3 (1 failing)415 530# fail416    `, '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 13425    ok 1 should pass > pass426    `, '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 13435 558ok 1 throws/notThrows > throws436 559ok 2 throws/notThrows > throws       7 lines hidden444 5671..8445 568# passing 8/8446 569# ok447    `, '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 13456 583not ok 1 throws/notThrows > throws457 584  ---       58 lines hidden516 6431..8517 644# passing 0/8 (8 failing)518 645# fail519    `, 'stdout');520      t.is(stderr, '', 'stderr');    646`,    647    "stdout",    648  );    649  t.is(stderr, "", "stderr");521 650  t.end();522 651});