tape-six 0.9.0

package/src/test.js

@@ -0,0 +1,187 @@
+import {selectTimer} from './utils/timer.js';
+import State, {StopTest} from './State.js';
+import Tester from './Tester.js';
+import Deferred from './utils/Deferred.js';
+import timeout from './utils/timeout.js';
+import {formatTime} from './utils/formatters.js';
+
+let tests = [],
+  reporter = null,
+  testCounter = 0,
+  isConfigured = false;
+
+export const getConfiguredFlag = () => isConfigured;
+export const setConfiguredFlag = value => (isConfigured = !!value);
+
+const processArgs = (name, options, testFn) => {
+  // normalize arguments
+  if (typeof name == 'function') {
+    testFn = name;
+    options = null;
+    name = '';
+  } else if (typeof name == 'object') {
+    testFn = options;
+    options = name;
+    name = null;
+  }
+  if (typeof options == 'function') {
+    testFn = options;
+    options = null;
+  }
+
+  // normalize options
+  options = {...options};
+  if (name && typeof name == 'string') {
+    options.name = name;
+  }
+  if (testFn && typeof testFn == 'function') {
+    options.testFn = testFn;
+  }
+  if (!options.name && typeof options.testFn == 'function' && options.testFn.name) {
+    options.name = options.testFn.name;
+  }
+  if (!options.name) {
+    options.name = '(anonymous)';
+  }
+
+  return options;
+};
+
+let isTimerSet = false;
+export const test = async (name, options, testFn) => {
+  options = processArgs(name, options, testFn);
+  if (!isTimerSet) {
+    await selectTimer();
+    isTimerSet = true;
+  }
+  const deferred = new Deferred();
+  tests.push({options, deferred});
+  return deferred.promise;
+};
+
+export const getTests = () => tests;
+export const clearTests = () => (tests = []);
+
+export const getReporter = () => reporter;
+export const setReporter = newReporter => (reporter = newReporter);
+
+export const runTests = async (rootState, tests) => {
+  for (let i = 0; i < tests.length; ++i) {
+    const {options, deferred} = tests[i],
+      testNumber = ++testCounter,
+      state = new State(rootState, options),
+      tester = new Tester(state, testNumber);
+    if (state.skip) {
+      tester.comment('SKIP test: ' + options.name);
+    } else {
+      try {
+        state.emit({type: 'test', name: options.name, test: testNumber, time: state.timer.now()});
+        if (options.skip) {
+          state.emit({type: 'comment', name: 'SKIP test: ' + options.name, test: testNumber, time: state.timer.now()});
+        } else if (options.testFn) {
+          if (options.timeout && !isNaN(options.timeout) && options.timeout > 0) {
+            const result = options.testFn(tester);
+            if (result && typeof result == 'object' && typeof result.then == 'function') {
+              const timedOut = await Promise.race([result.then(() => false), timeout(options.timeout).then(() => true)]);
+              if (timedOut) {
+                state.emit({
+                  type: 'comment',
+                  name: 'TIMED OUT after ' + formatTime(options.timeout) + ', test: ' + options.name,
+                  test: testNumber,
+                  time: state.timer.now()
+                });
+                await result;
+              }
+            }
+          } else {
+            await options.testFn(tester);
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof StopTest)) {
+          state.emit({
+            name: 'UNEXPECTED EXCEPTION: ' + String(error),
+            test: testNumber,
+            marker: new Error(),
+            time: state.timer.now(),
+            operator: 'error',
+            fail: true,
+            data: {
+              actual: error
+            }
+          });
+        }
+      }
+      state.emit({type: 'end', name: options.name, test: testNumber, time: state.timer.now(), fail: state.failed > 0, data: state});
+      state.updateParent();
+    }
+    deferred && deferred.resolve(state);
+  }
+};
+
+test.skip = function skip(name, options, testFn) {
+  options = processArgs(name, options, testFn);
+  return test({...options, skip: true});
+};
+
+test.todo = function todo(name, options, testFn) {
+  options = processArgs(name, options, testFn);
+  return test({...options, todo: true});
+};
+
+test.asPromise = function asPromise(name, options, testFn) {
+  options = processArgs(name, options, testFn);
+  if (options.testFn) {
+    const testFn = options.testFn;
+    options.testFn = tester => new Promise((resolve, reject) => {
+      try {
+        testFn(tester, resolve, reject)
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  return test(options);
+};
+
+// test() (an embedded test runner) is added here to ./Tester.js to avoid circular dependencies
+
+Tester.prototype.test = async function test(name, options, testFn) {
+  options = processArgs(name, options, testFn);
+  if (this.state.skip) {
+    this.comment('SKIP test: ' + options.name);
+  } else {
+    await runTests(this.state, [{options}]);
+  }
+};
+
+Tester.prototype.skip = async function skip(name, options, testFn) {
+  options = processArgs(name, options, testFn);
+  this.comment('SKIP test: ' + options.name);
+};
+
+Tester.prototype.todo = async function todo(name, options, testFn) {
+  options = processArgs(name, options, testFn);
+  if (this.state.skip) {
+    this.comment('SKIP test: ' + options.name);
+  } else {
+    await runTests(this.state, [{options: {...options, todo: true}}]);
+  }
+};
+
+Tester.prototype.asPromise = async function asPromise(name, options, testFn) {
+  options = processArgs(name, options, testFn);
+  if (options.testFn) {
+    const testFn = options.testFn;
+    options.testFn = tester => new Promise((resolve, reject) => {
+      try {
+        testFn(tester, resolve, reject)
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  await runTests(this.state, [{options}]);
+};
+
+export default test;

package/src/utils/Deferred.js

@@ -0,0 +1,10 @@
+class Deferred {
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+}
+
+export default Deferred;

package/src/utils/EventServer.js

@@ -0,0 +1,78 @@
+import defer from './defer.js';
+
+export default class EventServer {
+  constructor(reporter, numberOfTasks = 1, options = {}) {
+    this.reporter = reporter;
+    this.numberOfTasks = numberOfTasks;
+    this.options = options;
+
+    this.totalTasks = 0;
+    this.fileQueue = [];
+    this.passThroughId = null;
+    this.backlog = {};
+    this.closed = {};
+  }
+  report(id, event) {
+    if (this.passThroughId === null) this.passThroughId = id;
+    if (this.passThroughId === id) return this.reporter(event);
+    const events = this.backlog[id];
+    if (Array.isArray(events)) {
+      events.push(event);
+    } else {
+      this.backlog[id] = [event];
+    }
+  }
+  close(id) {
+    this.destroyTask(id);
+    --this.totalTasks;
+    if (this.fileQueue.length) {
+      ++this.totalTasks;
+      const nextFile = this.fileQueue.shift();
+      defer(() => {
+        const id = this.makeTask(nextFile);
+        this.report(id, {type: 'comment', name: 'FILE: /' + nextFile, test: 0});
+      });
+    }
+    if (this.passThroughId === id) {
+      this.passThroughId = null;
+      Object.keys(this.closed).forEach(id => {
+        const events = this.backlog[id];
+        if (!events) return;
+        events.forEach(event => this.reporter(event));
+        delete this.backlog[id];
+      });
+      this.closed = {};
+      const ids = Object.keys(this.backlog);
+      if (ids.length) {
+        const id = (this.passThroughId = ids[0]),
+          events = this.backlog[id];
+        if (events) {
+          events.forEach(event => this.reporter(event));
+          delete this.backlog[id];
+        }
+      }
+    } else {
+      this.closed[id] = 1;
+    }
+    !this.totalTasks && this.done && this.done();
+  }
+  createTask(fileName) {
+    if (this.totalTasks < this.numberOfTasks) {
+      ++this.totalTasks;
+      const id = this.makeTask(fileName);
+      this.report(id, {type: 'comment', name: 'FILE: /' + fileName, test: 0});
+    } else {
+      this.fileQueue.push(fileName);
+    }
+  }
+  execute(files) {
+    files.forEach(fileName => this.createTask(fileName));
+  }
+  makeTask(fileName) {
+    // TBD in children
+    // should return a task id as a string
+  }
+  destroyTask(id) {
+    // TBD in children
+  }
+}

package/src/utils/box.js

@@ -0,0 +1,101 @@
+export const stringRep = (n, str = ' ') => {
+  n = Math.max(0, Math.floor(n));
+  if (!n) return '';
+  let s = str,
+    buffer = '';
+  for (;;) {
+    n & 1 && (buffer += s);
+    n >>= 1;
+    if (!n) break;
+    s += s;
+  }
+  return buffer;
+};
+
+export const findEscSequence = /\x1B(?:\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]|[\x20-\x2F]*[\x30-\x7E])/g;
+export const getLength = str => String(str).replace(findEscSequence, '').length;
+
+export const normalizeBox = (strings, symbol = ' ', align = 'right') => {
+  const maxLength = strings.reduce((acc, s) => Math.max(acc, getLength(s)), 0);
+  return strings.map(s => {
+    const padding = stringRep(maxLength - getLength(s), symbol);
+    switch (align) {
+      case 'left':
+        return padding + s;
+      case 'center':
+        const half = padding.length >> 1;
+        return padding.substr(0, half) + s + padding.substr(half);
+    }
+    return s + padding;
+  });
+};
+
+export const padBoxRight = (strings, n, symbol = ' ') => {
+  const padding = stringRep(n, symbol);
+  return strings.map(s => s + padding);
+};
+
+export const padBoxLeft = (strings, n, symbol = ' ') => {
+  const padding = stringRep(n, symbol);
+  return strings.map(s => padding + s);
+};
+
+export const padBoxTop = (strings, n, symbol = ' ') => {
+  const string = stringRep(getLength(strings[0]), symbol),
+    result = [];
+  for (; n > 0; --n) result.push(string);
+  strings.forEach(s => result.push(s));
+  return result;
+};
+
+export const padBoxBottom = (strings, n, symbol = ' ') => {
+  const string = stringRep(getLength(strings[strings.length - 1]), symbol),
+    result = [...strings];
+  for (; n > 0; --n) result.push(string);
+  return result;
+};
+
+export const padBox = (strings, t, r, b, l, symbol) => {
+  if (typeof r != 'number') {
+    symbol = r;
+    r = b = l = t;
+  } else if (typeof b != 'number') {
+    symbol = b;
+    l = r;
+    b = t;
+  } else if (typeof l != 'number') {
+    symbol = l;
+    l = r;
+  }
+  if (typeof symbol != 'string') symbol = ' ';
+  if (t > 0) strings = padBoxTop(strings, t, symbol);
+  if (b > 0) strings = padBoxBottom(strings, b, symbol);
+  if (r > 0) strings = padBoxRight(strings, r, symbol);
+  if (l > 0) strings = padBoxLeft(strings, l, symbol);
+  return strings;
+};
+
+export const drawBox = strings => {
+  const maxLength = strings.reduce((acc, s) => Math.max(acc, getLength(s)), 0),
+    line = stringRep(maxLength, '\u2500'),
+    result = ['\u256D' + line + '\u256E'];
+  strings.forEach(s => result.push('\u2502' + s + '\u2502'));
+  result.push('\u2570' + line + '\u256F');
+  return result;
+};
+
+export const stackVertically = (a, b) => [...a, ...b];
+
+export const stackHorizontally = (a, b, symbol = ' ') => {
+  const n = Math.min(a.length, b.length),
+    result = [];
+  for (let i = 0; i < n; ++i) result.push(a[i] + b[i]);
+  if (a.length < b.length) {
+    const maxLength = a.reduce((acc, s) => Math.max(acc, getLength(s)), 0),
+      string = stringRep(maxLength, symbol);
+    for (let i = n; i < b.length; ++i) result.push(string + b[i]);
+  } else {
+    for (let i = n; i < a.length; ++i) result.push(a[i]);
+  }
+  return result;
+};

package/src/utils/defer.js

@@ -0,0 +1,33 @@
+let deferImplementation;
+
+// initialize the variable
+if (typeof setImmediate == 'function') {
+  deferImplementation = setImmediate;
+} else if (typeof window == 'object' && typeof window.postMessage == 'function' && typeof window.addEventListener == 'function') {
+  let buffer = [];
+  window.addEventListener(
+    'message',
+    evt => {
+      const src = evt.source;
+      if ((src === window || src === null) && evt.data === 'tape6-process-tick') {
+        evt.stopPropagation();
+        if (buffer.length) {
+          const tasks = buffer.slice(0);
+          buffer = [];
+          tasks.forEach(fn => fn());
+        }
+      }
+    },
+    true
+  );
+  deferImplementation = fn => {
+    buffer.push(fn);
+    window.postMessage('tape6-process-tick', '*');
+  };
+} else {
+  deferImplementation = setTimeout;
+}
+
+const defer = fn => deferImplementation(fn);
+
+export default defer;

package/src/utils/fileSets.js

@@ -0,0 +1,113 @@
+// file sets are represented as sorted name lists with no duplicated items
+
+export const normalize = fileSet => fileSet.sort().filter((name, i, list) => !i || list[i - 1] !== name);
+
+export const union = (a, b) => {
+  if (!a.length) return b.slice(0);
+  if (!b.length) return a.slice(0);
+
+  let i = 0,
+    j = 0,
+    x = a[0],
+    y = b[0];
+
+  const result = [];
+  for (;;) {
+    if (x < y) {
+      result.push(x);
+      ++i;
+      if (i >= a.length) break;
+      x = a[i];
+    } else if (x > y) {
+      result.push(y);
+      ++j;
+      if (j >= b.length) break;
+      y = b[j];
+    } else {
+      result.push(x);
+      ++i;
+      ++j;
+      if (i >= a.length || j >= b.length) break;
+      x = a[i];
+      y = b[j];
+    }
+  }
+
+  if (i < a.length) {
+    result.push(...a.slice(i));
+  } else if (j < b.length) {
+    result.push(...b.slice(j));
+  }
+
+  return result;
+};
+
+export const intersection = (a, b) => {
+  if (!a.length || !b.length) return [];
+
+  let i = 0,
+    j = 0,
+    x = a[0],
+    y = b[0];
+
+  const result = [];
+  for (;;) {
+    if (x < y) {
+      ++i;
+      if (i >= a.length) break;
+      x = a[i];
+    } else if (x > y) {
+      ++j;
+      if (j >= b.length) break;
+      y = b[j];
+    } else {
+      result.push(x);
+      ++i;
+      ++j;
+      if (i >= a.length || j >= b.length) break;
+      x = a[i];
+      y = b[j];
+    }
+  }
+
+  return result;
+};
+
+export const difference = (a, b) => {
+  if (!a.length) return [];
+  if (!b.length) return a.slice(0);
+
+  let i = 0,
+    j = 0,
+    x = a[0],
+    y = b[0];
+
+  const result = [];
+  for (;;) {
+    if (x < y) {
+      result.push(x);
+      ++i;
+      if (i >= a.length) break;
+      x = a[i];
+    } else if (x > y) {
+      ++j;
+      if (j >= b.length) break;
+      y = b[j];
+    } else {
+      ++i;
+      ++j;
+      if (i >= a.length || j >= b.length) break;
+      x = a[i];
+      y = b[j];
+    }
+  }
+
+  if (i < a.length) {
+    result.push(...a.slice(i));
+  }
+
+  return result;
+};
+
+export const filter = (a, re) => a.filter(item => re.test(item));
+export const exclude = (a, re) => a.filter(item => !re.test(item));

package/src/utils/formatters.js

@@ -0,0 +1,30 @@
+export const formatNumber = (n, precision = 0) => {
+  const s = Number(Math.abs(n)).toFixed(precision),
+    [i, f] = precision ? s.split('.') : [s];
+  if (!f && i.length <= 3) return n < 0 ? '-' + s : s;
+  const parts = [];
+  let start = i.length % 3;
+  start && parts.push(i.substr(0, start));
+  for (; start < i.length; start += 3) parts.push(i.substr(start, 3));
+  let result = parts.join(',');
+  f && !/^0*$/.test(f) && (result += '.' + f.replace(/0+$/, ''));
+  return n < 0 ? '-' + result : result;
+};
+
+const SEC = 1000,
+  MIN = 60 * SEC,
+  HOUR = 60 * MIN,
+  DAY = 24 * HOUR;
+
+const omit = (value, suffix, expected = '0') => (value === expected ? '' : value + suffix);
+
+export const formatTime = ms => {
+  if (ms < 10) return formatNumber(ms, 3) + 'ms';
+  if (ms < 100) return formatNumber(ms, 2) + 'ms';
+  if (ms < SEC) return formatNumber(ms, 1) + 'ms';
+  if (ms < 10000) return formatNumber(ms / SEC, 3) + 's';
+  if (ms < MIN) return formatNumber(ms / SEC, 2) + 's';
+  if (ms < HOUR) return formatNumber(Math.floor(ms / MIN), 0) + 'm' + omit(formatNumber(Math.floor((ms % MIN) / SEC), 0), 's');
+  if (ms < DAY) return formatNumber(Math.floor(ms / HOUR), 0) + 'h' + omit(formatNumber(Math.floor((ms % HOUR) / MIN), 0), 'm');
+  return formatNumber(Math.floor(ms / DAY), 0) + 'd' + omit(formatNumber(Math.floor((ms % DAY) / HOUR), 0), 'h');
+};

package/src/utils/timeout.js

@@ -0,0 +1,3 @@
+const timeout = async delay => new Promise(resolve => setTimeout(resolve, delay, delay));
+
+export default timeout;

package/src/utils/timer.js

@@ -0,0 +1,24 @@
+let timer = Date;
+
+export const getTimer = () => timer;
+export const setTimer = newTimer => (timer = newTimer);
+
+export const selectTimer = async () => {
+  // set HR timer
+  if (typeof performance == 'object' && performance && typeof performance.now == 'function') {
+    // browser or Deno
+    setTimer(performance);
+    return;
+  }
+  if (typeof process == 'object' && typeof process.exit == 'function') {
+    // Node
+    try {
+      const {performance} = await import('perf_hooks');
+      setTimer(performance);
+      return;
+    } catch (error) {
+      // squelch
+    }
+  }
+  setTimer(Date);
+};