@nutin/cli 1.3.0 → 2.0.0

package/templates/base/tools/testin-nutin/core/coverage/compute-coverage.js.hbs

@@ -0,0 +1,115 @@
+import fs from 'fs';
+import path from 'path';
+import { errorExit } from '../../../utils/index.js';
+
+// V8 ranges within a script are always disjoint or strictly nested, never partially
+// overlapping. The smallest range containing an offset holds the true execution count
+// for that offset - e.g. "this function ran 5x but this one branch inside it ran 0x".
+function countAt(offset, ranges) {
+  let best = null;
+  for (const range of ranges) {
+    if (offset < range.startOffset || offset >= range.endOffset) continue;
+    if (!best || (range.endOffset - range.startOffset) < (best.endOffset - best.startOffset)) {
+      best = range;
+    }
+  }
+  return best ? best.count : 0;
+}
+
+function buildLineStarts(sourceText) {
+  const starts = [0];
+  for (let i = 0; i < sourceText.length; i++) {
+    if (sourceText[i] === '\n') starts.push(i + 1);
+  }
+  return starts;
+}
+
+function offsetToLine(offset, lineStarts) {
+  let lo = 0, hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1;
+    if (lineStarts[mid] <= offset) lo = mid; else hi = mid - 1;
+  }
+  return lo + 1; // 1-indexed
+}
+
+// V8 sometimes reports an empty functionName (e.g. accessors, unnamed callbacks).
+// Fall back to reading the source at the function's own start offset instead of a
+// meaningless placeholder - covers `constructor(`, `get foo(`, method names, etc.
+// Only treat a leading identifier as a real name when it's immediately followed by
+// `(` (a param list) - otherwise it's just an arrow function's bare parameter (e.g.
+// `c => ...`), which isn't a name at all, so fall through to a source snippet instead.
+function deriveLabel(sourceText, startOffset) {
+  const snippet = sourceText.slice(startOffset, startOffset + 60);
+  const named = snippet.match(/^\s*(?:get |set )?([A-Za-z_$][\w$]*)\s*\(/);
+  if (named) return named[1];
+  return snippet.trim().split('\n')[0].slice(0, 30) || '<anonymous>';
+}
+
+export function computeFileCoverage({ functions }, sourceText) {
+  const allRanges = functions.flatMap(fn => fn.ranges);
+  const lineStarts = buildLineStarts(sourceText);
+
+  // Line coverage: sample the count at each line's first non-whitespace character.
+  // Not statement/branch-accurate, but simple and good enough for a lightweight report.
+  let offset = 0;
+  let totalLines = 0;
+  let coveredLines = 0;
+  const uncoveredLines = [];
+  for (const line of sourceText.split('\n')) {
+    const firstChar = line.search(/\S/);
+    if (firstChar !== -1) {
+      totalLines++;
+      if (countAt(offset + firstChar, allRanges) > 0) coveredLines++;
+      else uncoveredLines.push(offsetToLine(offset + firstChar, lineStarts));
+    }
+    offset += line.length + 1;
+  }
+
+  // Function coverage: every functions[] entry except the whole-script pseudo-function,
+  // identified by its first range spanning the entire file.
+  const realFunctions = functions.filter(fn => {
+    const [topRange] = fn.ranges;
+    return !(topRange.startOffset === 0 && topRange.endOffset === sourceText.length);
+  });
+  const coveredFunctions = realFunctions.filter(fn => fn.ranges[0].count > 0).length;
+  const uncoveredFunctions = realFunctions
+    .filter(fn => fn.ranges[0].count === 0)
+    .map(fn => ({
+      name: fn.functionName || deriveLabel(sourceText, fn.ranges[0].startOffset),
+      line: offsetToLine(fn.ranges[0].startOffset, lineStarts),
+    }));
+
+  // Branch coverage: every range beyond a function's own top-level range (index 0)
+  // is a nested conditional block V8 already tracked while collecting detailed
+  // coverage - if/else arms, ternary branches, switch cases, logical short-circuits,
+  // loop bodies. No AST parsing needed, just reusing data already being collected.
+  const allBranchRanges = functions.flatMap(fn => fn.ranges.slice(1));
+  const coveredBranches = allBranchRanges.filter(r => r.count > 0).length;
+  const uncoveredBranches = allBranchRanges
+    .filter(r => r.count === 0)
+    .map(r => offsetToLine(r.startOffset, lineStarts))
+    .sort((a, b) => a - b);
+
+  return {
+    totalLines, coveredLines, uncoveredLines,
+    linesPct: totalLines ? (coveredLines / totalLines) * 100 : 100,
+    totalBranches: allBranchRanges.length, coveredBranches, uncoveredBranches,
+    branchesPct: allBranchRanges.length ? (coveredBranches / allBranchRanges.length) * 100 : 100,
+    totalFunctions: realFunctions.length, coveredFunctions, uncoveredFunctions,
+    functionsPct: realFunctions.length ? (coveredFunctions / realFunctions.length) * 100 : 100,
+  };
+}
+
+export function buildCoverageReport(scopedResults) {
+  return scopedResults.map(entry => {
+    let sourceText;
+    try {
+      sourceText = fs.readFileSync(entry.filePath, 'utf-8');
+    } catch (err) {
+      errorExit(err, 'coverage/compute-coverage');
+    }
+    const coverage = computeFileCoverage(entry, sourceText);
+    return { file: path.relative(process.cwd(), entry.filePath), ...coverage };
+  });
+}

package/templates/base/tools/testin-nutin/core/coverage/compute-coverage.test.js.hbs

@@ -0,0 +1,74 @@
+import { computeFileCoverage } from './compute-coverage.js';
+
+describe('computeFileCoverage', () => {
+  it('reports 100% when every function and line ran', () => {
+    const sourceText = 'function covered() {\n  return 1;\n}\n';
+    const scriptResult = {
+      functions: [
+        { functionName: '', ranges: [{ startOffset: 0, endOffset: sourceText.length, count: 1 }] },
+        { functionName: 'covered', ranges: [{ startOffset: 0, endOffset: sourceText.length - 1, count: 3 }] },
+      ],
+    };
+
+    const { linesPct, functionsPct, branchesPct } = computeFileCoverage(scriptResult, sourceText);
+    expect(linesPct).toEqual(100);
+    expect(functionsPct).toEqual(100);
+    expect(branchesPct).toEqual(100); // no nested ranges anywhere -> defaults to 100
+  });
+
+  it('reports 0% for a function that never ran', () => {
+    const sourceText = 'function uncovered() {\n  return 1;\n}\n';
+    const scriptResult = {
+      functions: [
+        { functionName: '', ranges: [{ startOffset: 0, endOffset: sourceText.length, count: 1 }] },
+        { functionName: 'uncovered', ranges: [{ startOffset: 0, endOffset: sourceText.length - 1, count: 0 }] },
+      ],
+    };
+
+    const { linesPct, functionsPct } = computeFileCoverage(scriptResult, sourceText);
+    expect(linesPct).toEqual(0);
+    expect(functionsPct).toEqual(0);
+  });
+
+  it('lets a nested 0-count branch override its enclosing covered range', () => {
+    const sourceText = 'function branchy(flag) {\n  if (flag) {\n    return 1;\n  }\n  return 2;\n}\n';
+    const branchStart = sourceText.indexOf('return 1');
+    const branchEnd = sourceText.indexOf(';', branchStart) + 1;
+
+    const scriptResult = {
+      functions: [
+        { functionName: '', ranges: [{ startOffset: 0, endOffset: sourceText.length, count: 1 }] },
+        {
+          functionName: 'branchy',
+          ranges: [
+            { startOffset: 0, endOffset: sourceText.length - 1, count: 5 },
+            { startOffset: branchStart, endOffset: branchEnd, count: 0 },
+          ],
+        },
+      ],
+    };
+
+    const { linesPct, totalBranches, coveredBranches, branchesPct } = computeFileCoverage(scriptResult, sourceText);
+    // every line covered except the never-taken "return 1;" branch
+    expect(linesPct).toEqual(5 / 6 * 100);
+    expect(totalBranches).toEqual(1);
+    expect(coveredBranches).toEqual(0);
+    expect(branchesPct).toEqual(0);
+  });
+
+  it('derives a name from the source when V8 reports an empty functionName', () => {
+    const sourceText = 'class Foo {\n  constructor(x) {\n    this.x = x;\n  }\n}\n';
+    const constructorStart = sourceText.indexOf('constructor');
+    const constructorEnd = sourceText.indexOf('}', constructorStart) + 1;
+
+    const scriptResult = {
+      functions: [
+        { functionName: '', ranges: [{ startOffset: 0, endOffset: sourceText.length, count: 1 }] },
+        { functionName: '', ranges: [{ startOffset: constructorStart, endOffset: constructorEnd, count: 0 }] },
+      ],
+    };
+
+    const { uncoveredFunctions } = computeFileCoverage(scriptResult, sourceText);
+    expect(uncoveredFunctions).toEqual([{ name: 'constructor', line: 2 }]);
+  });
+});

package/templates/base/tools/testin-nutin/core/coverage/write-summary-report.js.hbs

@@ -0,0 +1,54 @@
+import fs from 'fs';
+import path from 'path';
+import { print, toTsPath } from '../printer.js';
+import { errorExit } from '../../../utils/index.js';
+import config from '#root/nutin.config.js';
+
+const REPORT_PATH = path.join('coverage', 'summary.md');
+
+export function writeSummaryReport(report, globals, testResults) {
+  if (!report.length) return;
+
+  try {
+    fs.mkdirSync(path.dirname(REPORT_PATH), { recursive: true });
+    fs.writeFileSync(REPORT_PATH, buildMarkdown(report, globals, testResults));
+  } catch (err) {
+    errorExit(err, 'coverage/write-summary-report');
+  }
+  print.info(`Wrote ${REPORT_PATH}\n`);
+}
+
+function buildMarkdown(report, globals, testResults) {
+  const rows = report
+    .slice()
+    .sort((a, b) => a.file.localeCompare(b.file))
+    .map(r => `| ${toTsPath(r.file)} | ${r.linesPct.toFixed(1)} | ${r.functionsPct.toFixed(1)} | ${r.branchesPct.toFixed(1)} |`)
+    .join('\n');
+
+  const threshold = config.testinNutin.coverage?.threshold;
+  const thresholdLine = typeof threshold === 'number' ? `\n- Threshold: ${threshold}%` : '';
+
+  const { todo, passed, failed, elapsedTime } = testResults;
+  const total = passed + failed;
+  const todoLine = todo > 0 ? `\n- ⚠️ To do: ${todo}` : '';
+
+  return `# Coverage Summary
+
+## Test Summary
+
+- ✓ ${passed} passed
+- ✗ ${failed} failed
+- 📖 ${total} total
+- ⌚️ Time: ${elapsedTime.toFixed(2)}ms${todoLine}
+
+| File | Lines % | Functions % | Branches % |
+|---|---|---|---|
+${rows}
+
+## Global
+
+- Lines: ${globals.globalLinesPct.toFixed(1)}%
+- Functions: ${globals.globalFunctionsPct.toFixed(1)}%
+- Branches: ${globals.globalBranchesPct.toFixed(1)}%${thresholdLine}
+`;
+}

package/templates/base/tools/testin-nutin/core/coverage/write-uncovered-report.js.hbs

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import { print } from '../printer.js';
+import { errorExit } from '../../../utils/index.js';
+import config from '#root/nutin.config.js';
+
+const REPORT_PATH = path.join('coverage', 'uncovered.md');
+
+export async function maybeWriteUncoveredReport(report) {
+  const uncovered = report.filter(r => r.uncoveredLines.length || r.uncoveredBranches.length || r.uncoveredFunctions.length);
+  if (!uncovered.length) {
+    print.info('🎉 No uncovered code found.\n');
+    return;
+  }
+
+  if (!config.testinNutin.coverage.reportUncovered) return;
+
+  try {
+    fs.mkdirSync(path.dirname(REPORT_PATH), { recursive: true });
+    fs.writeFileSync(REPORT_PATH, buildMarkdown(uncovered));
+  } catch (err) {
+    errorExit(err, 'coverage/write-uncovered-report');
+  }
+  print.info(`Wrote ${REPORT_PATH}\n`);
+}
+
+function buildMarkdown(uncovered) {
+  const sections = uncovered
+    .sort((a, b) => a.file.localeCompare(b.file))
+    .map(r => {
+      const branches = r.uncoveredBranches.length
+        ? `Uncovered branches (lines): ${r.uncoveredBranches.join(', ')}\n`
+        : '';
+      const fns = r.uncoveredFunctions.length
+        ? `Uncovered functions:\n${r.uncoveredFunctions.map(f => `- \`${f.name}\` (line ${f.line})`).join('\n')}\n`
+        : '';
+      const lines = r.uncoveredLines.length
+        ? `Uncovered lines: ${r.uncoveredLines.join(', ')}\n`
+        : '';
+      return `## ${r.file}\n\n${branches}${fns}${lines}`;
+    });
+
+  return `# Uncovered Code\n\nIMPORTANT: Line numbers refer to **compiled** .js code (\`dist/src/\`).\n\n${sections.join('\n')}`;
+}

package/templates/{features/testinNutin/testin-nutin/core/src → base/tools/testin-nutin/core}/globals/assertion-lib.js.hbs

@@ -1,8 +1,17 @@
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+
+global.AssertionError = AssertionError;
+
 global.expect = (actual) => {
   const expectObj = {
     toBe(expected) {
       if (actual !== expected) {
-        throw new Error(`Expected ${actual} to be strictly equal to ${expected}`);
+        throw new AssertionError(`Expected ${actual} to be strictly equal to ${expected}`);
       }
     },
     toEqual(expected) {
@@ -22,42 +31,42 @@ global.expect = (actual) => {
       };
 
       if (!deepEqual(actual, expected)) {
-        throw new Error(`Expected ${JSON.stringify(actual)} to deeply equal ${JSON.stringify(expected)}`);
+        throw new AssertionError(`Expected ${JSON.stringify(actual)} to deeply equal ${JSON.stringify(expected)}`);
       }
     },
     toContain(substring) {
       if (!actual.includes(substring)) {
-        throw new Error(`Expected '${actual}' to contain '${substring}'`);
+        throw new AssertionError(`Expected '${actual}' to contain '${substring}'`);
       }
     },
     toBeTruthy() {
       if (!actual) {
-        throw new Error(`Expected ${actual} to be truthy`);
+        throw new AssertionError(`Expected ${actual} to be truthy`);
       }
     },
     toBeFalsy() {
       if (actual) {
-        throw new Error(`Expected ${actual} to be falsy`);
+        throw new AssertionError(`Expected ${actual} to be falsy`);
       }
     },
     toBeDefined() {
       if (actual === null || actual === undefined) {
-        throw new Error(`Expected value to be defined, but got ${actual}`);
+        throw new AssertionError(`Expected value to be defined, but got ${actual}`);
       }
     },
     toBeUndefined() {
       if (actual !== null && actual !== undefined) {
-        throw new Error(`Expected value to be undefined, but got ${actual}`);
+        throw new AssertionError(`Expected value to be undefined, but got ${actual}`);
       }
     },
     toBeInstanceOf(constructor) {
       if (!(actual instanceof constructor)) {
-        throw new Error(`Expected ${actual} to be instance of ${constructor.name}`);
+        throw new AssertionError(`Expected ${actual} to be instance of ${constructor.name}`);
       }
     },
     toHaveBeenCalled() {
       if (!actual?.calls || actual.calls.length === 0) {
-        throw new Error(`Expected function to have been called, but it was not`);
+        throw new AssertionError(`Expected function to have been called, but it was not`);
       }
     },
     toHaveBeenCalledWith(...expectedArgs)  {
@@ -85,7 +94,7 @@ global.expect = (actual) => {
       );
 
       if (!matched) {
-        throw new Error(
+        throw new AssertionError(
           `Expected function to have been called with ${JSON.stringify(expectedArgs)}, but it was not.\n` +
           `Actual calls:\n${JSON.stringify(actual?.calls, null, 2)}`
         );
@@ -93,27 +102,40 @@ global.expect = (actual) => {
     },
     toBeLessThan(expected) {
       if (actual > expected) {
-        throw new Error(`Expected ${actual} to be less than ${expected}`)
+        throw new AssertionError(`Expected ${actual} to be less than ${expected}`)
       }
     },
     toBeGreaterThan(expected) {
       if (actual < expected) {
-        throw new Error(`Expected ${actual} to be greater than ${expected}`)
+        throw new AssertionError(`Expected ${actual} to be greater than ${expected}`)
       }
     },
     toThrow(expectedMessage) {
-      let threw = false;
-      try {
-        actual();
-      } catch (err) {
-        threw = true;
+      const checkMessage = (err) => {
         if (expectedMessage && !err.message.includes(expectedMessage)) {
-          throw new Error(`Expected error message to include "${expectedMessage}", but got "${err.message}"`);
+          throw new AssertionError(`Expected error message to include "${expectedMessage}", but got "${err.message}"`);
         }
+      };
+
+      let result;
+      try {
+        result = actual();
+      } catch (err) {
+        checkMessage(err);
+        return;
       }
-      if (!threw) {
-        throw new Error(`Expected function to throw, but it did not`);
+
+      // actual() returned a promise (async function) — it can only reject
+      // asynchronously, so return a promise the caller must await instead of
+      // throwing synchronously.
+      if (result && typeof result.then === 'function') {
+        return result.then(
+          () => { throw new AssertionError(`Expected function to throw, but it did not`); },
+          (err) => { checkMessage(err); }
+        );
       }
+
+      throw new AssertionError(`Expected function to throw, but it did not`);
     },
   };
 
@@ -124,12 +146,28 @@ global.expect = (actual) => {
     if (typeof fn !== 'function') continue;
 
     expectObj.not[name] = (...args) => {
+      const settle = (err) => {
+        if (err) {
+          if (err instanceof AssertionError) return;
+          throw err;
+        }
+        throw new AssertionError(`Expected NOT: ${name}(${JSON.stringify(args)})`);
+      };
+
+      let result;
       try {
-        fn(...args);
-      } catch {
-        return;
+        result = fn(...args);
+      } catch (err) {
+        return settle(err);
       }
-      throw new Error(`Expected NOT: ${name}(${JSON.stringify(args)})`);
+
+      // Only toThrow(), given an async function, can return a promise here —
+      // every other matcher (and toThrow given a sync function) is synchronous.
+      if (result && typeof result.then === 'function') {
+        return result.then(() => settle(), (err) => settle(err));
+      }
+
+      return settle();
     };
   }
   return expectObj;

package/templates/base/tools/testin-nutin/core/globals/clock.js.hbs

@@ -0,0 +1,206 @@
+let _installed = false;
+let _now = 0;                  // virtual clock, ms since epoch
+let _idSeq = 1;                // fake timer id counter — starts at 1, never falsy
+const _timers = new Map();     // id -> { id, type: 'timeout'|'interval', callback, args, delay, due }
+let _originals = null;         // real fns captured at install time
+const MAX_LOOP_ITERATIONS = 100000;
+
+function _schedule(type, cb, delay, args) {
+  if (typeof cb !== 'function') {
+    throw new Error(`${type === 'timeout' ? 'setTimeout' : 'setInterval'} requires a function callback`);
+  }
+  const id = _idSeq++;
+  const safeDelay = Math.max(0, Number(delay) || 0);
+  _timers.set(id, { id, type, callback: cb, args, delay: safeDelay, due: _now + safeDelay });
+  return id;
+}
+
+const fakeSetTimeout = (cb, delay = 0, ...args) => _schedule('timeout', cb, delay, args);
+const fakeSetInterval = (cb, delay = 0, ...args) => _schedule('interval', cb, delay, args);
+const fakeClearTimeout = (id) => { _timers.delete(id); };
+const fakeClearInterval = fakeClearTimeout;
+
+function _makeFakeDate(RealDate) {
+  return class FakeDate extends RealDate {
+    constructor(...args) {
+      if (args.length === 0) {
+        super(_now);
+      } else {
+        super(...args);
+      }
+    }
+    static now() {
+      return _now;
+    }
+  };
+}
+
+// Sugar over the fake timers rather than relying on jsdom-setup.js's
+// `window.requestAnimationFrame ??= (cb) => setTimeout(cb, 0)` shim, which is
+// dead code with `pretendToBeVisual: true` jsdom config
+const fakeRequestAnimationFrame = (cb) => fakeSetTimeout(() => cb(_now), 16);
+const fakeCancelAnimationFrame = (id) => fakeClearTimeout(id);
+
+function _assertFake(name) {
+  if (!_installed) {
+    throw new Error(`${name}() requires useFakeTimers() to be called first`);
+  }
+}
+
+function _earliestDue(predicate) {
+  let best = null;
+  for (const timer of _timers.values()) {
+    if (predicate(timer) && (!best || timer.due < best.due || (timer.due === best.due && timer.id < best.id))) {
+      best = timer;
+    }
+  }
+  return best;
+}
+
+function _fire(timer) {
+  if (timer.type === 'timeout') {
+    _timers.delete(timer.id);
+    timer.callback(...timer.args);
+  } else {
+    timer.due += timer.delay;
+    timer.callback(...timer.args);
+  }
+}
+
+global.useFakeTimers = function useFakeTimers() {
+  if (_installed) return;
+
+  _originals = {
+    setTimeout: global.setTimeout,
+    clearTimeout: global.clearTimeout,
+    setInterval: global.setInterval,
+    clearInterval: global.clearInterval,
+    Date: global.Date,
+    requestAnimationFrame: global.requestAnimationFrame,
+    cancelAnimationFrame: global.cancelAnimationFrame,
+    windowSetTimeout: typeof window !== 'undefined' ? window.setTimeout : undefined,
+    windowClearTimeout: typeof window !== 'undefined' ? window.clearTimeout : undefined,
+    windowSetInterval: typeof window !== 'undefined' ? window.setInterval : undefined,
+    windowClearInterval: typeof window !== 'undefined' ? window.clearInterval : undefined,
+    windowDate: typeof window !== 'undefined' ? window.Date : undefined,
+    windowRequestAnimationFrame: typeof window !== 'undefined' ? window.requestAnimationFrame : undefined,
+    windowCancelAnimationFrame: typeof window !== 'undefined' ? window.cancelAnimationFrame : undefined,
+  };
+
+  _now = _originals.Date.now();
+  _idSeq = 1;
+  _timers.clear();
+
+  const FakeDate = _makeFakeDate(_originals.Date);
+
+  global.setTimeout = fakeSetTimeout;
+  global.clearTimeout = fakeClearTimeout;
+  global.setInterval = fakeSetInterval;
+  global.clearInterval = fakeClearInterval;
+  global.Date = FakeDate;
+  // Compiled app code calls the bare `requestAnimationFrame` identifier, which
+  // resolves via normal scope lookup to `global.requestAnimationFrame` — not
+  // `window.requestAnimationFrame` — so both must be faked, not just window's.
+  global.requestAnimationFrame = fakeRequestAnimationFrame;
+  global.cancelAnimationFrame = fakeCancelAnimationFrame;
+
+  if (typeof window !== 'undefined') {
+    window.setTimeout = fakeSetTimeout;
+    window.clearTimeout = fakeClearTimeout;
+    window.setInterval = fakeSetInterval;
+    window.clearInterval = fakeClearInterval;
+    window.Date = FakeDate;
+    window.requestAnimationFrame = fakeRequestAnimationFrame;
+    window.cancelAnimationFrame = fakeCancelAnimationFrame;
+  }
+
+  _installed = true;
+};
+
+global.useRealTimers = function useRealTimers() {
+  if (!_installed) return;
+
+  global.setTimeout = _originals.setTimeout;
+  global.clearTimeout = _originals.clearTimeout;
+  global.setInterval = _originals.setInterval;
+  global.clearInterval = _originals.clearInterval;
+  global.Date = _originals.Date;
+  global.requestAnimationFrame = _originals.requestAnimationFrame;
+  global.cancelAnimationFrame = _originals.cancelAnimationFrame;
+
+  if (typeof window !== 'undefined') {
+    window.setTimeout = _originals.windowSetTimeout;
+    window.clearTimeout = _originals.windowClearTimeout;
+    window.setInterval = _originals.windowSetInterval;
+    window.clearInterval = _originals.windowClearInterval;
+    window.Date = _originals.windowDate;
+    window.requestAnimationFrame = _originals.windowRequestAnimationFrame;
+    window.cancelAnimationFrame = _originals.windowCancelAnimationFrame;
+  }
+
+  _timers.clear();
+  _installed = false;
+  _originals = null;
+};
+
+global.advanceTimersByTime = function advanceTimersByTime(ms) {
+  _assertFake('advanceTimersByTime');
+  const target = _now + Math.max(0, Number(ms) || 0);
+  let iterations = 0;
+
+  for (;;) {
+    const next = _earliestDue(timer => timer.due <= target);
+    if (!next) break;
+    if (++iterations > MAX_LOOP_ITERATIONS) {
+      throw new Error(`advanceTimersByTime: exceeded ${MAX_LOOP_ITERATIONS} timer firings — likely an interval rescheduling itself with delay 0`);
+    }
+    _now = next.due;
+    _fire(next);
+  }
+
+  _now = target;
+};
+
+global.tick = global.advanceTimersByTime;
+
+global.runAllTimers = function runAllTimers() {
+  _assertFake('runAllTimers');
+  let iterations = 0;
+
+  while (_timers.size > 0) {
+    if (++iterations > MAX_LOOP_ITERATIONS) {
+      throw new Error(`runAllTimers: aborting after ${MAX_LOOP_ITERATIONS} timers — likely an infinite loop (e.g. an uncleared setInterval)`);
+    }
+    const next = _earliestDue(() => true);
+    _now = Math.max(_now, next.due);
+    _fire(next);
+  }
+};
+
+global.runOnlyPendingTimers = function runOnlyPendingTimers() {
+  _assertFake('runOnlyPendingTimers');
+  const pendingIds = new Set(_timers.keys());
+
+  for (;;) {
+    const next = _earliestDue(timer => pendingIds.has(timer.id));
+    if (!next) break;
+    pendingIds.delete(next.id);
+    _now = Math.max(_now, next.due);
+    _fire(next);
+  }
+};
+
+global.clearAllTimers = function clearAllTimers() {
+  _assertFake('clearAllTimers');
+  _timers.clear();
+};
+
+global.getTimerCount = function getTimerCount() {
+  _assertFake('getTimerCount');
+  return _timers.size;
+};
+
+global.setSystemTime = function setSystemTime(msOrDate) {
+  _assertFake('setSystemTime');
+  _now = msOrDate instanceof Date ? msOrDate.getTime() : Number(msOrDate);
+};