scriptc/tests/fixtures/npm/node_modules/node24-no-error-assertion-fixture/index.js

import assert from "node:assert";
import strict from "assert/strict";

export async function reportNoErrorAssertions() {
  const describe = (error, original, expected) => error === original ? "original" : JSON.stringify({
    name: error?.name, code: error?.code, message: error?.message,
    operator: error?.operator, actual: error?.actual === original,
    expected: error?.expected === (typeof expected === "string" ? undefined : expected),
    generatedMessage: error?.generatedMessage,
  });
  const sync = (label, original, expected, message) => {
    try { assert.doesNotThrow(() => { throw original; }, expected, message); console.log(label, "pass"); }
    catch (error) { console.log(label, describe(error, original, expected)); }
  };
  const asyncCase = async (label, original, expected, message) => {
    try { await strict.doesNotReject(Promise.reject(original), expected, message); console.log(label, "pass"); }
    catch (error) { console.log(label, describe(error, original, expected)); }
  };
  const values = [undefined, null, false, 0, -0, 42, "text", 1n, Symbol("tag"), {},
    { message: 0 }, { message: false }, { message: null }, { message: "object failure" },
    new Error("boom"), new RangeError("boom"), new TypeError("")];
  const expectations = [undefined, null, false, 0, NaN, "", "note", Error, RangeError, TypeError,
    /Error: boom/, /text/, /Symbol\(tag\)/, () => true, () => false, () => 1, () => "yes", () => undefined,
    1, {}, []];
  for (let i = 0; i < values.length; i++) {
    for (let j = 0; j < expectations.length; j++) {
      sync(`sync-${i}-${j}`, values[i], expectations[j], "");
      await asyncCase(`async-${i}-${j}`, values[i], expectations[j], "");
    }
  }
  let calls = 0;
  for (const expected of expectations) {
    assert.doesNotThrow(() => { calls++; }, expected);
    await assert.doesNotReject(Promise.resolve(42), expected);
  }
  console.log("unused-expectations", calls);

  const original = new RangeError("boom");
  const regex = /^RangeError: boom$/g;
  regex.test = () => { throw new Error("overridden test"); };
  regex.exec = () => { throw new Error("overridden exec"); };
  sync("global-first", original, regex);
  console.log("index-first", regex.lastIndex);
  sync("global-second", original, regex);
  console.log("index-second", regex.lastIndex);
  const receivers = [];
  function validator(actual) {
    console.log("validator", actual === original, Object.getPrototypeOf(this) === Object.prototype, Object.keys(this).length);
    receivers.push(this);
    return false;
  }
  sync("validator-sync", original, validator);
  await asyncCase("validator-async", original, validator);
  console.log("fresh-receiver", receivers[0] !== receivers[1]);
  const sentinel = { marker: true };
  try { assert.doesNotThrow(() => { throw original; }, () => { throw sentinel; }); }
  catch (error) { console.log("validator-throw", error === sentinel); }
  try { await assert.doesNotReject(Promise.reject(original), () => { throw sentinel; }); }
  catch (error) { console.log("async-validator-throw", error === sentinel); }
  const getterFailure = { get message() { throw sentinel; } };
  try { assert.doesNotThrow(() => { throw getterFailure; }); }
  catch (error) { console.log("message-getter-throw", error === sentinel); }
  try { await assert.doesNotReject(Promise.reject(getterFailure)); }
  catch (error) { console.log("async-message-getter-throw", error === sentinel); }

  for (const input of [null, undefined, 0, 1, "x", {}, [], Symbol("tag")]) {
    try { assert.doesNotThrow(input); } catch (error) { console.log("invalid-fn", error.name, error.code, error.message); }
    try { await assert.doesNotReject(input); } catch (error) { console.log("invalid-promise", error.name, error.code, error.message); }
    try { await assert.doesNotReject(() => input); } catch (error) { console.log("invalid-return", error.name, error.code, error.message); }
  }
  let validatorCalled = false;
  try { await assert.doesNotReject(() => { throw sentinel; }, () => { validatorCalled = true; return true; }); }
  catch (error) { console.log("sync-callback-failure", error === sentinel, validatorCalled); }
  await assert.doesNotReject({ then(resolve) { resolve(42); }, catch() {} });
  const thenableExpected = /Error: boom/;
  try { await assert.doesNotReject({ then(_resolve, reject) { reject(original); }, catch() {} }, thenableExpected); }
  catch (error) { console.log("thenable", describe(error, original, thenableExpected)); }
  const timing = [];
  const pending = assert.doesNotReject(() => { timing.push("callback"); return Promise.resolve(); }).then(() => timing.push("done"));
  Promise.resolve().then(() => timing.push("microtask"));
  timing.push("returned");
  await pending;
  console.log("timing", timing.join(","));
}