@lumjs/tests 1.1.1 → 1.3.0

package/CHANGELOG.md

@@ -6,6 +6,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.0] - 2022-07-27
+### Added
+- `$call()` function; powers `call()`, `lives()`, `dies()`, and `diesWith()`. 
+- `call()` method; test the result of a function call.
+- `diesWith()` method; like `dies()` but also tests the thrown `Error`.
+- `run()` method; for running a bunch of similar tests with a compact syntax.
+### Changed
+- How `functional` gets its list of test methods to proxy.
+- Cleaned up a bunch of stuff in the `Log` class.
+- Added a `details.info` structure to the `Log` class.
+- Refactored `lives()` and `dies()` to use the new `$call()` function.
+- Updated `ok()` to support passing `details` to it directly.
+- Some further cleanups in the `Test` class.
+
+## [1.2.0] - 2022-07-26
+### Added
+- `lives()` method; the inverse of `dies()`.
+- `nota()` method; the inverse of `isa()`.
+- `isntJSON()` method; the inverse of `isJSON()`.
+- Tests for `isa()`, `isJSON()`, and all the new methods.
+### Changed
+- `isa()` uses `core.types.isa()` method now.
+- `isa()` supports multiple `wants` values, just use an Array.
+- Anything that used `JSON.stringify()` now uses `core.types.stringify()`.
+
 ## [1.1.1] - 2022-07-15
 ### Fixed
 - Dependency issue in `package.json` with pre-release parent.
@@ -32,7 +57,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Ported from Lum.js v4 library set.
 - Added a few more features from the PHP version.
 
-[Unreleased]: https://github.com/supernovus/lum.tests.js/compare/v1.1.1...HEAD
+[Unreleased]: https://github.com/supernovus/lum.tests.js/compare/v1.3.0...HEAD
+[1.3.0]: https://github.com/supernovus/lum.tests.js/compare/v1.2.0...v1.3.0
+[1.2.0]: https://github.com/supernovus/lum.tests.js/compare/v1.1.1...v1.2.0
 [1.1.1]: https://github.com/supernovus/lum.tests.js/compare/v1.1.0...v1.1.1
 [1.1.0]: https://github.com/supernovus/lum.tests.js/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/supernovus/lum.tests.js/releases/tag/v1.0.0

package/TODO.md

@@ -1,7 +1,10 @@
 # TODO
 
-- Add tests for `isa()` method.
+- Write tests for:
+  - `call()`
+  - `diesWith()`
+  - `run()`
 - Write the `Harness` class, based of the Lum.php version.
 - Add tests for `Harness`.
-- Create 'lumtest' binary for running the harness without `prove` utility.
+- Create `lumtest` binary for running the harness without `prove` utility.
 

package/lib/functional.js

@@ -2,11 +2,7 @@
 const Test = require('./test');
 
 // A list of methods we can proxy directly.
-const PROXY_METHODS = 
-[
-  'plan', 'ok', 'fail', 'pass', 'dies', 'cmp', 'isa', 'is', 'isnt', 
-  'isJSON', 'skip', 'diag', 'tap', 'output',
-];
+const PROXY_METHODS = Test.$METHODS.all;
 
 /**
  * A new test instance and a set of functions wrapping it.
@@ -16,20 +12,6 @@ const PROXY_METHODS =
  * All of the rest of the properties are functions that
  * can be imported into a JS scope using destructuring, and
  * which wrap the corresponding test instance method.
- * 
- * @property {function} plan 
- * @property {function} ok
- * @property {function} fail 
- * @property {function} pass 
- * @property {function} dies 
- * @property {function} cmp 
- * @property {function} isa 
- * @property {function} is 
- * @property {function} isnt 
- * @property {function} isJSON 
- * @property {function} skip 
- * @property {function} diag 
- * @property {function} tap  
  */
 
 /**

package/lib/log.js

@@ -1,5 +1,6 @@
 
-const {F,S,O} = require('@lumjs/core').types;
+const types = require('@lumjs/core').types;
+const {F,S,O,isArray,stringify} = types;
 
 /**
  * A log representing the results of a test.
@@ -34,7 +35,7 @@ class Log
    * Generally this is never needed to be used by outside code.
    * The `Test.tap()` method uses it when generating a full log.
    * 
-   * @param {*} num - The test #
+   * @param {*} num - The test number.
    * @returns {string} The TAP log.
    */
   tap (num)
@@ -53,7 +54,7 @@ class Log
     if (typeof this.directive === S)
       out += ' # ' + this.directive;
     else if (typeof this.directive == O && this.directive instanceof Error)
-      out += ' # ' + this.directive.name + ': ' + this.directive.message;
+      out += ` # ${this.directive.name}: ${this.directive.message}`;
     else if (this.skipped)
       out += ' # SKIP ' + this.skippedReason;
 
@@ -65,14 +66,28 @@ class Log
       var want = this.details.wanted;
       if (this.details.stringify)
       {
-        got = (typeof got === F) ? got.toString() : JSON.stringify(got);
-        want = (typeof want === F) ? want.toString() : JSON.stringify(want);
+        got = stringify(got);
+        want = stringify(want);
       }
-      out += '#       got: ' + got + "\n";
-      out += '#  expected: ' + want + "\n";
+      out += `#       got: ${got}\n`;
+      out += `#  expected: ${want}\n`;
       if (typeof this.details.comparitor === S)
       {
-        out += '#        op: ' + this.details.comparitor + "\n";
+        out += `#        op: ${this.details.comparitor}\n`;
+      }
+    }
+
+    if ('info' in this.details)
+    { // Extended information. Usually an array, but can be whatever.
+      const info 
+        = isArray(this.details.info) 
+        ? this.details.info
+        : [this.details.info];
+
+      for (const i in info)
+      {
+        const line = (typeof info[i] === S) ? info[i] : stringify(info[i]);
+        out += `## ${line}\n`;
       }
     }
 

package/lib/test.js

@@ -1,9 +1,38 @@
 const core = require('@lumjs/core');
-const {F,S,N,isType,isObj,isInstance,def} = core.types;
+const types = core.types;
+const {F,S,N,isObj,isArray,def} = types;
 
 // We use a separate class to represent test logs.
 const Log = require('./log');
 
+// A list of Test methods that return Log objects.
+const TEST_METHODS =
+[
+  'ok', 'call', 'fail', 'pass', 'dies', 'diesWith', 'lives', 'cmp', 
+  'is', 'isnt', 'isa', 'nota', 'isJSON', 'isntJSON', 'skip',
+];
+
+// A list of other methods to export that are not standard tests.
+const META_METHODS = 
+[
+  'plan', 'diag', 'run', 'tap', 'output',
+];
+
+// The function that powers `Test.call()` and friends.
+function $call (testfunc, args)
+{
+  const ret = {};
+  try
+  {
+    ret.val = testfunc(...args);
+  }
+  catch (e)
+  {
+    ret.err = e;
+  }
+  return ret;
+}
+
 /**
  * A simple testing library with TAP support.
  * 
@@ -106,13 +135,12 @@ class Test
    *   If the value evaluates as `true` (aka a truthy value), the test passes.
    *   If it evaluates as `false` (a falsey value), the test fails.
    * 
-   * @param {string} desc - A short description of the test.
-   * 
+   * @param {string} [desc] A short description of the test.
    * @param {(string|Error)} [directive] Further information for the log.
-   *    
+   * @param {object} [details] Extra details to add to the log.
    * @returns {Log} The test log with the results.
    */
-  ok (test, desc, directive)
+  ok (test, desc, directive, details)
   {
     const log = new Log();
 
@@ -135,11 +163,34 @@ class Test
       log.directive = directive;
     }
 
+    if (isObj(details))
+    {
+      log.details = details;
+    }
+
     this.log.push(log);
 
     return log;
   }
 
+  /**
+   * Run a function and pass its return value to `ok()`.
+   *
+   * @param {function} testfunc - The function to run.
+   *   If the function returns, the return value will be passed to `ok()`.
+   *   If it throws an Error, the test will be marked as failed, and the
+   *   Error will be passed as the `directive` to the `ok()` method.
+   *
+   * @param {string} [desc] A description for `ok()`.
+   * @param {...any} [args] Arguments to pass to the test function.
+   * @returns {Log}
+   */
+  call(testfunc, desc, ...args)
+  {
+    const ret = $call(testfunc, args);
+    return this.ok(ret.val, desc, ret.err);
+  }
+
   /**
    * Mark a test as failed.
    * 
@@ -174,20 +225,91 @@ class Test
    * call. If no error is caught the test will be considered to have failed.
    * 
    * @param {function} testfunc 
-   * @param {string} desc 
+   * @param {string} [desc] 
+   * @param {...any} [args]
+   * @returns {Log}
+   */
+  dies (testfunc, desc, ...args)
+  {
+    const ret = $call(testfunc, args);
+    return this.ok(('err' in ret), desc, ret.err);
+  }
+
+  /**
+   * See if a function throws an Error, and if the Error passes a second test.
+   * 
+   * All the notes that apply to `dies()` apply here as well.
+   *
+   * @param {function} testfunc - Same as `dies()` and `call()`
+   *   We don't care about the return value of this function.
+   *   We only care that it *should* throw an Error.
+   *
+   * @param {(function|string)} testerr - A test to validate the Error.
+   *
+   * If this is a `function` it will be passed the thrown `Error` as the first
+   * parameter, and an `Array` of `args` as the second parameter. The return
+   * value from this will be passed to `ok()`.
+   *
+   * If this is a `string` then the test will pass only if the either the
+   * `Error.name` or `Error.message` is exactly equal to this value.
+   *
+   * @param {string} [desc] 
+   * @param {...any} [args]
    * @returns {Log}
    */
-  dies (testfunc, desc)
+  diesWith(testfunc, testerr, desc, ...args)
   {
-    let ok = false;
-    let err;
-    try { testfunc(); } 
-    catch (e)
+    let ok = false, details = {}, err = null;
+
+    const r1 = $call(testfunc, args);
+
+    if ('err' in r1)
     {
-      ok = true;
-      err = e;
-    }
-    return this.ok(ok, desc, err);
+      err = r1.err;
+
+      if (typeof testerr === F)
+      { // A secondary function to test the error with.
+        const r2 = $call(testerr, [err, args]);
+        if ('err' in r2)
+        { // Second function threw an error, add it as diagnostic info.
+          details.info = r2.err;
+        }
+        else
+        { // No error, use the function output as the test value.
+          ok = r2.val;
+        }
+      }
+      else if (typeof testerr === S)
+      { // A simple name/message test.
+        if (err.name === testerr || err.message === testerr)
+        { // Either the name or the message matched the string.
+          ok = true;
+        }
+      }
+      
+    } // if r1.err
+
+    return this.ok(ok, desc, err, details);
+  }
+
+  /**
+   * See if a function runs without throwing an Error.
+   * 
+   * The function will be called in a `try { } catch (err) { }` block.
+   * 
+   * If an error is caught, the test will be considered to have failed,
+   * and the `Error` object will be used as the `directive` in the `ok()`
+   * call. If no error is caught the test will be considered to have passed.
+   * 
+   * @param {function} testfunc 
+   * @param {string} [desc] 
+   * @param {...any} [args]
+   * @returns {Log}
+   */
+  lives (testfunc, desc, ...args)
+  {
+    const ret = $call(testfunc, args);
+    return this.ok(!('err' in ret), desc, ret.err);
   }
 
   /**
@@ -253,15 +375,19 @@ class Test
         test = false; 
     }
 
-    const log = this.ok(test, desc);
+    let details = null;
     if (!test)
-    {
-      log.details.got = got;
-      log.details.wanted = want;
-      log.details.stringify = stringify;
-      log.details.comparitor = comp;
+    { // The test failed, add the deets.
+      details = 
+      {
+        got, 
+        wanted: want,
+        stringify,
+        comparitor: comp,
+      };
     }
-    return log;
+
+    return this.ok(test, desc, null, details);
   }
 
   /**
@@ -271,7 +397,7 @@ class Test
    * 
    * @param {*} got 
    * @param {*} want 
-   * @param {string} desc 
+   * @param {string} [desc] 
    * @param {boolean} [stringify=true]
    * @returns {Log}
    */
@@ -287,8 +413,8 @@ class Test
    * 
    * @param {*} got - The result value from the test function.
    * @param {*} want - The value we expected from the test function.
-   * @param {string} desc 
-   * @param {boolean} [stringify=true] Use JSON details in TAP output?
+   * @param {string} [desc] 
+   * @param {boolean} [stringify=true]
    * @returns {Log}
    */
   isnt (got, want, desc, stringify=true)
@@ -300,45 +426,64 @@ class Test
    * See if a value is of a certain type.
    * 
    * @param {*} got 
-   * @param {(string|function)} want - A type name, or a constructor function.
+   * @param {Array} wants - Type names or constructor functions.
    * 
-   * This uses two type checking functions from `@lumsj/core`.
-   * If this is a string, we use the `isType()` function.
-   * If this is a constructor function, we use the `isInstance()` function.
+   * Uses `@lumjs/core/types.isa()` to perform the test.
    *  
-   * @param {string} desc 
+   * @param {string} [desc]
    * @param {boolean} [stringify=true]
    * @returns {Log}
    */
-  isa (got, want, desc, stringify=true)
+  isa (got, wants, desc, stringify=true, not=false)
   {
-    let test;
-    if (typeof want === S)
-    { // A string, we're going to use the isType function.
-      test = isType(want, got);
-    }
-    else if (typeof want === F)
-    { // Assuming it's a constructor.
-      test = isInstance(got, want);
+    if (!isArray(wants))
+    {
+      wants = [wants];
     }
-    else 
-    { // That's not supported.
-      throw new TypeError("'want' must be a string or a constructor");
+    let res = types.isa(got, ...wants);
+    if (not)
+    { // Inverse the result.
+      res = !res;
     }
 
-    const log = this.ok(test, desc);
-    if (!test)
-    {
-      log.details.got = got;
-      log.details.wanted = want;
-      log.details.stringify = stringify;
+    let details = null;
+    if (!res)
+    { // The test failed, add the deets.
+      details = 
+      {
+        got, 
+        wanted: wants,
+        stringify,
+        comparitor: not ? 'nota()' : 'isa()',
+      };
     }
-    return log;
+
+    return this.ok(res, desc, null, details);
+  }
+
+  /**
+   * See if a value is NOT of a certain type.
+   *
+   * Just inverses the results of `isa()`.
+   *
+   * @param {*} got
+   * @param {Array} wants - Type names of constructor functions.
+   * @param {string} [desc]
+   * @param {boolean} [stringify=true]
+   * @returns {Log}
+   */
+  nota (got, wants, desc, stringify=true)
+  {
+    return this.isa(got, wants, desc, stringify, true);
   }
 
   /**
    * An `is()` test, but encode both values as JSON first.
    * 
+   * Actually uses `core.types.stringify()` so it supports more
+   * data types than standard JSON, and can stringify functions,
+   * symbols, and several extended object types.
+   * 
    * @param {*} got 
    * @param {*} want 
    * @param {string} desc 
@@ -346,11 +491,28 @@ class Test
    */
   isJSON (got, want, desc)
   {
-    got = JSON.stringify(got);
-    want = JSON.stringify(want);
+    got = types.stringify(got);
+    want = types.stringify(want);
     return this.is(got, want, desc, false);
   }
 
+  /**
+   * An `isnt()` test, but encode both values as JSON first.
+   * 
+   * Like `isJSON()` this uses `core.types.stringify()`.
+   * 
+   * @param {*} got 
+   * @param {*} want 
+   * @param {string} desc 
+   * @returns 
+   */
+  isntJSON (got, want, desc)
+  {
+    got = types.stringify(got);
+    want = types.stringify(want);
+    return this.isnt(got, want, desc, false);
+  }
+
   /**
    * Skip a test.
    * 
@@ -381,6 +543,58 @@ class Test
     this.log.push(msg);
   }
 
+  /**
+   * Run an assortment of tests using a map.
+   *
+   * The *current* test method defaults to `ok`.
+   *
+   * @param {...any} tests - The tests we're running.
+   *
+   * If this is a `string`, and is the name of one of the standard testing
+   * methods in this class, it will be set as the *current* test method.
+   *
+   * If this is a `function`, it will be set as the *current* test method.
+   * Function test methods are passed to `call()` with the test parameters.
+   *
+   * If this is an `Array` then it's the parameters for the *current* test
+   * method. If a custom `function` is in use, remember that the *first*
+   * parameter is **always** the `desc`, and any subsequent parameters will be
+   * passed to the custom `function` call.
+   *
+   * Any value other than one of those will throw a `TypeError`.
+   *
+   * @returns {Log[]} A `Log` item for each test that was ran.
+   */
+  run(...tests)
+  {
+    const logs = [];
+    let current = 'ok';
+    
+    for (const test of tests)
+    {
+      const tt = typeof test;
+      if (tt === F || (tt === S && TEST_METHODS.includes(test)))
+      { // Set the current test.
+        current = test;
+      }
+      else if (isArray(test))
+      { // A set of test parameters.
+        let log;
+        if (typeof current === F)
+        { // A custom test function is in use.
+          log = this.call(current, ...test);
+        }
+        else
+        { // A standard test is in use.
+          log = this[current](...test);
+        }
+        logs.push(log);
+      }
+    }
+
+    return logs;
+  }
+
   /**
    * Return TAP formatted output for all the tests.
    * 
@@ -403,7 +617,7 @@ class Test
       }
       else
       { // A comment.
-        out += '# ' + (typeof log === S ? log : JSON.stringify(log)) + "\n";
+        out += '# ' + (typeof log === S ? log : types.stringify(log)) + "\n";
       }
     }
     if (this.skipped)
@@ -439,5 +653,29 @@ class Test
 // Should never need this, but...
 def(Test, 'Log', Log);
 
+// Probably don't need this either, but...
+def(Test, '$call', $call);
+
+// Methods we're exporting for the 'functional' API.
+def(Test, '$METHODS',
+{
+  test: TEST_METHODS,
+  meta: META_METHODS,
+  get all()
+  {
+    const list = [];
+    for (const name in this)
+    {
+      if (name === 'all') continue;
+      const prop = this[name];
+      if (isArray(prop))
+      {
+        list.push(...prop);
+      }
+    }
+    return list;
+  },
+});
+
 // Export the class
 module.exports = Test;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumjs/tests",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "main": "lib/index.js",
   "license": "MIT",
   "repository":

package/test/basics.js

@@ -1,5 +1,6 @@
 const Test = require('../lib').Test;
 const def = require('./inc/basics.js');
+const stringify = def.types.stringify;
 
 const test = new Test();
 test.plan(def.plan);
@@ -9,22 +10,39 @@ test.pass('pass()');
 
 for (const is of def.isTests)
 {
-  const t = JSON.stringify(is);
+  const t = stringify(is);
   test.is(is, is, 'is('+t+','+t+')');
 }
 
 for (const [a,b] of def.isntTests)
 {
-  const msg = `isnt(${JSON.stringify(a)},${JSON.stringify(b)})`;
+  const msg = `isnt(${stringify(a)},${stringify(b)})`;
   test.isnt(a, b, msg);
 }
 
 for (const args of def.cmpTests)
 {
-  const msg = 'cmp('+JSON.stringify(args)+')';
+  const msg = 'cmp('+stringify(args)+')';
   test.cmp(...args, msg);
 }
 
+for (const func of def.livesTests)
+{
+  test.lives(func, `lives(${stringify(func)})`);
+}
+
+for (const [a,b] of def.isJsonTests)
+{
+  const msg = `isJSON(${stringify(a)},${stringify(b)})`;
+  test.isJSON(a, b, msg);
+}
+
+for (const [a,b] of def.isntJsonTests)
+{
+  const msg = `isntJSON(${stringify(a)},${stringify(b)})`;
+  test.isntJSON(a, b, msg);
+}
+
 // We're done, output the log.
 console.log(test.tap());
 

package/test/functional_basics.js

@@ -1,7 +1,11 @@
 // Testing the basic functions of the functional testing API.
 
-const {test,plan,ok,pass,is,isnt,cmp,tap} = require('../lib').functional();
+const 
+{
+  test,plan,ok,pass,is,isnt,cmp,tap,isJSON,isntJSON,lives,
+} = require('../lib').functional();
 const def = require('./inc/basics.js');
+const stringify = def.types.stringify;
 
 plan(def.plan);
 
@@ -10,22 +14,39 @@ pass('pass()');
 
 for (const it of def.isTests)
 {
-  const t = JSON.stringify(it);
+  const t = stringify(it);
   is(it, it, 'is('+t+','+t+')');
 }
 
 for (const [a,b] of def.isntTests)
 {
-  const msg = `isnt(${JSON.stringify(a)},${JSON.stringify(b)})`;
+  const msg = `isnt(${stringify(a)},${stringify(b)})`;
   isnt(a, b, msg);
 }
 
 for (const args of def.cmpTests)
 {
-  const msg = 'cmp('+JSON.stringify(args)+')';
+  const msg = 'cmp('+stringify(args)+')';
   cmp(...args, msg);
 }
 
+for (const func of def.livesTests)
+{
+  lives(func, `lives(${stringify(func)})`);
+}
+
+for (const [a,b] of def.isJsonTests)
+{
+  const msg = `isJSON(${stringify(a)},${stringify(b)})`;
+  isJSON(a, b, msg);
+}
+
+for (const [a,b] of def.isntJsonTests)
+{
+  const msg = `isntJSON(${stringify(a)},${stringify(b)})`;
+  isntJSON(a, b, msg);
+}
+
 // We're done, output the log.
 console.log(tap());
 

package/test/functional_isa.js

@@ -0,0 +1,23 @@
+const {test,plan,tap,isa,nota} = require('../lib').functional();
+const def = require('./inc/isa.js');
+const getLabel = def.label;
+
+plan(def.plan);
+
+for (const isaTest of def.isaTests)
+{
+  const label = getLabel('isa',isaTest);
+  isa(isaTest[0], isaTest[1], label);
+}
+
+for (const notaTest of def.notaTests)
+{
+  const label = getLabel('nota',notaTest);
+  nota(notaTest[0], notaTest[1], label);
+}
+
+// We're done, output the log.
+console.log(tap());
+
+// And re-export the test.
+module.exports = test;

package/test/inc/basics.js

@@ -1,4 +1,5 @@
 // Common stuff for both regular and functional tests.
+const types = require('@lumjs/core').types;
 
 const okay = (1==1);
 
@@ -33,10 +34,39 @@ const cmpTests =
   // TODO: finish this set of tests.
 ];
 
+const livesTests = 
+[ // Tests for the lives() function.
+  () => true,
+  () => JSON.stringify({answer:42}),
+  () => JSON.parse('{"hello":"world"}'),
+];
+
+const isJsonTests = 
+[
+  [[1,2,3], [1,2,3]],
+  [['hello','world'], ['hello','world']],
+  [{hello: 'world'}, {hello:'world'}],
+];
+
+const isntJsonTests = 
+[
+  [[1,2,3], [3,2,1]],
+  [['hello','world'], ['goodbye','universe']],
+  [{hello: 'world'}, {hello:'darkness my old friend'}],
+];
+
 const plan 
   = 2
   + isTests.length
   + isntTests.length
-  + cmpTests.length;
+  + cmpTests.length
+  + livesTests.length
+  + isJsonTests.length
+  + isntJsonTests.length
+  ;
 
-module.exports = {okay, isTests, isntTests, cmpTests, plan};
+module.exports = 
+{
+  isTests, isntTests, cmpTests, livesTests, isJsonTests, isntJsonTests,
+  okay, plan, types,
+};

package/test/inc/isa.js

@@ -0,0 +1,110 @@
+// Common stuff for isa() and nota() tests.
+const types = require('@lumjs/core').types;
+// A quick reference to the type names.
+const TYP = types.TYPES;
+
+// I based most of these off of the tests in `@lumjs/core`.
+// Some almost verbatim, but others required restructuring.
+
+class TypeClass {}
+
+class SubtypeClass extends TypeClass {}
+
+const typesInstance = new TypeClass();
+const subtypeInstance = new SubtypeClass();
+
+class DifferentClass {}
+
+const differentInstance = new DifferentClass();
+
+function getArguments() { return arguments; }
+
+const MT = [TYP.S, TYP.N];
+const MC = [SubtypeClass, DifferentClass];
+const MM = [TYP.B, TypeClass];
+
+const MCT = ',[SubtypeClass,DifferentClass]';
+const MMT = ',["binary",TypeClass]';
+
+const isaTests = 
+[
+  // Single types.
+  [{}, TYP.O],
+  [function(){}, TYP.F],
+  ['hello', TYP.S],
+  [true, TYP.B],
+  [false, TYP.B],
+  [100, TYP.N],
+  [undefined, TYP.U],
+  [Symbol('foo'), TYP.SY],
+  [BigInt(12345), TYP.BI, 'BigInt(12345),'+TYP.BI],
+  [54321n, TYP.BI, '54321n,'+ TYP.BI],
+  [getArguments(), TYP.ARGS],
+  [[], TYP.ARRAY],
+  [null, TYP.NULL],
+  [new Int16Array(16), TYP.TYPEDARRAY, 'Int16Array(16),'+TYP.TYPEDARRAY],
+  [{value: true}, TYP.DESCRIPTOR],
+  [{get: function(){}}, TYP.DESCRIPTOR],
+  [{}, TYP.COMPLEX],
+  [function(){}, TYP.COMPLEX],
+  [true, TYP.SCALAR],
+  ['hi', TYP.SCALAR],
+  ['woah', TYP.PROP],
+  [Symbol('woah'), TYP.PROP],
+  // Single class.
+  [typesInstance, TypeClass, 'typesInstance,TypeClass'],
+  [subtypeInstance, SubtypeClass, 'subtypeInstance,SubtypeClass'],
+  [subtypeInstance, TypeClass, 'subtypeInstance,TypeClass'],
+  [differentInstance, DifferentClass, 'differentInstance,DifferentClass'],
+  // Multiples.
+  ['hello', MT],
+  [42, MT],
+  [subtypeInstance, MC, 'subtypeInstance'+MCT],
+  [differentInstance, MC, 'differentInstance'+MCT],
+  [true, MM, 'true'+MMT],
+  [false, MM, 'false'+MMT],
+  [typesInstance, MM, 'typeInstance'+MMT],
+  [subtypeInstance, MM, 'subtypeInstance'+MMT],
+];
+
+const notaTests =
+[
+  // Single types.
+  ['foo', TYP.O],
+  [null, TYP.O],
+  [{}, TYP.F],
+  [0, TYP.B],
+  [1, TYP.B],
+  ['0', TYP.N],
+  [null, TYP.U],
+  ['foo', TYP.SY],
+  [12345, TYP.BI],
+  [{}, TYP.ARGS],
+  [{}, TYP.ARRAY],
+  [false, TYP.NULL],
+  [[], TYP.TYPEDARRAY],
+  [{value: true, get: function(){}}, TYP.DESCRIPTOR],
+  [{}, TYP.DESCRIPTOR],
+  ['a string', TYP.COMPLEX],
+  [{}, TYP.SCALAR],
+  [null, TYP.PROP],
+  // Single class.
+  [typesInstance, SubtypeClass, 'typesInstance,SubtypeClass'],
+  [differentInstance, TypeClass, 'differentInstance,TypeClass'],
+  [typesInstance, DifferentClass, 'typesInstance,DifferentClass'],
+  // Multiples.
+  [{}, MT],
+  [typesInstance, MC, 'typesInstance'+MCT],
+  [null, MM, 'null'+MMT],
+];
+
+const plan = isaTests.length + notaTests.length;
+
+function label (f,t)
+{
+  return f+'('+((t.length === 3)
+    ? t[2]
+    : types.stringify(t[0])+','+types.stringify(t[1]))+')';
+}
+
+module.exports = {types, label, plan, isaTests, notaTests};

package/test/isa.js

@@ -0,0 +1,23 @@
+const Test = require('../lib').Test;
+const def = require('./inc/isa.js');
+
+const test = new Test();
+test.plan(def.plan);
+
+for (const isaTest of def.isaTests)
+{
+  const label = def.label('isa',isaTest);
+  test.isa(isaTest[0], isaTest[1], label);
+}
+
+for (const notaTest of def.notaTests)
+{
+  const label = def.label('nota',notaTest);
+  test.nota(notaTest[0], notaTest[1], label);
+}
+
+// We're done, output the log.
+console.log(test.tap());
+
+// Re-expect the test.
+module.exports = test;