vitest 0.0.109 → 0.0.113

package/dist/entry.js

@@ -1,18 +1,19 @@
 import fs, { promises } from 'fs';
-import { c as clearContext, e as defaultSuite, f as setHooks, h as getHooks, j as context, k as getFn, b as vi } from './vi-9754296d.js';
+import { f as equals, h as iterableEquality, j as subsetEquality, k as isA, J as JestChaiExpect, l as clearContext, m as defaultSuite, n as setHooks, o as getHooks, p as context, s as setState, q as getFn, b as getState, e as vi } from './vi-51946984.js';
 import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
 import chai$1, { expect, util } from 'chai';
 import { a as commonjsRequire, c as commonjsGlobal } from './_commonjsHelpers-c9e3b764.js';
-import { l as index, g as getNames, c as c$1, t as toArray, b as basename, o as interpretOnlyMode, p as partitionSuiteChildren, q as hasTests, j as hasFailed } from './utils-d97bd6d9.js';
+import { c as index, r as relative } from './index-1488b423.js';
 import { r as rpc, s as send } from './rpc-7de86f29.js';
-import { u as unifiedDiff } from './diff-46ee5d7d.js';
+import { s as slash, f as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, j as hasTests, h as hasFailed } from './index-041e627e.js';
+import { l as getOriginalPos, m as posToNumber, n as parseStack, u as unifiedDiff } from './diff-9c43ab50.js';
 import { performance } from 'perf_hooks';
-import { n as nanoid } from './jest-mock-8498c46d.js';
+import { n as nanoid } from './jest-mock-a57b745c.js';
 import { format as format$1 } from 'util';
-import 'tty';
 import 'path';
+import 'tty';
 import 'tinyspy';
 
 var node = {
@@ -382,6 +383,44 @@ var chaiSubset = {exports: {}};
 
 var Subset = chaiSubset.exports;
 
+async function saveInlineSnapshots(snapshots) {
+  const MagicString = (await import('./magic-string.es-94000aea.js')).default;
+  const files = new Set(snapshots.map((i) => i.file));
+  await Promise.all(Array.from(files).map(async (file) => {
+    const map = await rpc("getSourceMap", file, true);
+    const snaps = snapshots.filter((i) => i.file === file);
+    const code = await promises.readFile(file, "utf8");
+    const s = new MagicString(code);
+    for (const snap of snaps) {
+      const pos = await getOriginalPos(map, snap);
+      const index = posToNumber(code, pos);
+      replaceInlineSnap(code, s, index, snap.snapshot);
+    }
+    await promises.writeFile(file, s.toString(), "utf-8");
+  }));
+}
+const startRegex = /toMatchInlineSnapshot\s*\(\s*(['"`\)])/m;
+function replaceInlineSnap(code, s, index, newSnap) {
+  const startMatch = startRegex.exec(code.slice(index));
+  if (!startMatch)
+    return false;
+  newSnap = newSnap.replace(/\\/g, "\\\\");
+  const snapString = newSnap.includes("\n") ? `\`${newSnap.replace(/`/g, "\\`").trimEnd()}\`` : `'${newSnap.replace(/'/g, "\\'")}'`;
+  const quote = startMatch[1];
+  const startIndex = index + startMatch.index + startMatch[0].length;
+  if (quote === ")") {
+    s.appendRight(startIndex - 1, snapString);
+    return true;
+  }
+  const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
+  const endMatch = quoteEndRE.exec(code.slice(startIndex));
+  if (!endMatch)
+    return false;
+  const endIndex = startIndex + endMatch.index + endMatch[0].length;
+  s.overwrite(startIndex - 1, endIndex, snapString);
+  return true;
+}
+
 var naturalCompare$2 = {exports: {}};
 
 /*
@@ -1422,13 +1461,13 @@ var _collections$1 = collections;
 // SENTINEL constants are from https://github.com/facebook/immutable-js
 const IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
 const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
-const IS_KEYED_SENTINEL$1 = '@@__IMMUTABLE_KEYED__@@';
+const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
 const IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
-const IS_ORDERED_SENTINEL$1 = '@@__IMMUTABLE_ORDERED__@@';
+const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
 const IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@'; // immutable v4
 
 const IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
-const IS_SET_SENTINEL$1 = '@@__IMMUTABLE_SET__@@';
+const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
 const IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
 
 const getImmutableName = name => 'Immutable.' + name;
@@ -1517,7 +1556,7 @@ const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
     return printAsLeaf(name);
   }
 
-  if (val[IS_KEYED_SENTINEL$1]) {
+  if (val[IS_KEYED_SENTINEL]) {
     return (
       name +
       SPACE +
@@ -1590,7 +1629,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
       depth,
       refs,
       printer,
-      val[IS_ORDERED_SENTINEL$1] ? 'OrderedMap' : 'Map'
+      val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map'
     );
   }
 
@@ -1606,7 +1645,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
     );
   }
 
-  if (val[IS_SET_SENTINEL$1]) {
+  if (val[IS_SET_SENTINEL]) {
     return printImmutableValues(
       val,
       config,
@@ -1614,7 +1653,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
       depth,
       refs,
       printer,
-      val[IS_ORDERED_SENTINEL$1] ? 'OrderedSet' : 'Set'
+      val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set'
     );
   }
 
@@ -2187,7 +2226,7 @@ function _interopRequireDefault(obj) {
  */
 
 /* eslint-disable local/ban-types-eventually */
-const toString$1 = Object.prototype.toString;
+const toString = Object.prototype.toString;
 const toISOString = Date.prototype.toISOString;
 const errorToString = Error.prototype.toString;
 const regExpToString = RegExp.prototype.toString;
@@ -2299,7 +2338,7 @@ function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
     return printSymbol(val);
   }
 
-  const toStringed = toString$1.call(val);
+  const toStringed = toString.call(val);
 
   if (toStringed === '[object WeakMap]') {
     return 'WeakMap {}';
@@ -2375,7 +2414,7 @@ function printComplexValue(
     return printer(val.toJSON(), config, indentation, depth, refs, true);
   }
 
-  const toStringed = toString$1.call(val);
+  const toStringed = toString.call(val);
 
   if (toStringed === '[object Arguments]') {
     return hitMaxDepth
@@ -2830,13 +2869,13 @@ function ensureDirectoryExists(filePath) {
 function normalizeNewlines(string) {
   return string.replace(/\r\n|\r/g, "\n");
 }
-function saveSnapshotFile(snapshotData, snapshotPath) {
+async function saveSnapshotFile(snapshotData, snapshotPath) {
   const snapshots = Object.keys(snapshotData).sort(naturalCompare$1).map((key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`);
   ensureDirectoryExists(snapshotPath);
-  fs.writeFileSync(snapshotPath, `${writeSnapshotVersion()}
+  await promises.writeFile(snapshotPath, `${writeSnapshotVersion()}
 
 ${snapshots.join("\n\n")}
-`);
+`, "utf-8");
 }
 
 var __defProp$1 = Object.defineProperty;
@@ -2862,6 +2901,7 @@ class SnapshotState {
     this._initialData = data;
     this._snapshotData = data;
     this._dirty = dirty;
+    this._inlineSnapshots = [];
     this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
     this._counters = /* @__PURE__ */ new Map();
     this._index = 0;
@@ -2883,7 +2923,20 @@ class SnapshotState {
   }
   _addSnapshot(key, receivedSerialized, options) {
     this._dirty = true;
-    this._snapshotData[key] = receivedSerialized;
+    if (options.isInline) {
+      const error = options.error || new Error("Unknown error");
+      const stacks = parseStack(error.stack || "");
+      stacks.forEach((i) => i.file = slash(i.file));
+      const stack = stacks.find((i) => process.__vitest_worker__.ctx.files.includes(i.file));
+      if (!stack) {
+        throw new Error("Vitest: Couldn't infer stack frame for inline snapshot.");
+      }
+      this._inlineSnapshots.push(__spreadValues$1({
+        snapshot: receivedSerialized
+      }, stack));
+    } else {
+      this._snapshotData[key] = receivedSerialized;
+    }
   }
   clear() {
     this._snapshotData = this._initialData;
@@ -2894,16 +2947,19 @@ class SnapshotState {
     this.unmatched = 0;
     this.updated = 0;
   }
-  save() {
+  async save() {
     const hasExternalSnapshots = Object.keys(this._snapshotData).length;
-    const isEmpty = !hasExternalSnapshots;
+    const hasInlineSnapshots = this._inlineSnapshots.length;
+    const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots;
     const status = {
       deleted: false,
       saved: false
     };
     if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
       if (hasExternalSnapshots)
-        saveSnapshotFile(this._snapshotData, this._snapshotPath);
+        await saveSnapshotFile(this._snapshotData, this._snapshotPath);
+      if (hasInlineSnapshots)
+        await saveInlineSnapshots(this._inlineSnapshots);
       status.saved = true;
     } else if (!hasExternalSnapshots && fs.existsSync(this._snapshotPath)) {
       if (this._updateSnapshot === "all")
@@ -3019,7 +3075,7 @@ class SnapshotClient {
   clearTest() {
     this.test = void 0;
   }
-  assert(received, message, inlineSnapshot) {
+  assert(received, message, isInline = false, inlineSnapshot) {
     if (!this.test)
       throw new Error("Snapshot cannot be used outside of test");
     const testName = [
@@ -3029,7 +3085,7 @@ class SnapshotClient {
     const { actual, expected, key, pass } = this.snapshotState.match({
       testName,
       received,
-      isInline: !!inlineSnapshot,
+      isInline,
       inlineSnapshot: inlineSnapshot == null ? void 0 : inlineSnapshot.trim()
     });
     if (!pass) {
@@ -3044,13 +3100,13 @@ class SnapshotClient {
   async saveSnap() {
     if (!this.testFile || !this.snapshotState)
       return;
-    const result = packSnapshotState(this.testFile, this.snapshotState);
+    const result = await packSnapshotState(this.testFile, this.snapshotState);
     await rpc("snapshotSaved", result);
     this.testFile = "";
     this.snapshotState = void 0;
   }
 }
-function packSnapshotState(filepath, state) {
+async function packSnapshotState(filepath, state) {
   const snapshot = {
     filepath,
     added: 0,
@@ -3065,7 +3121,7 @@ function packSnapshotState(filepath, state) {
   const uncheckedKeys = state.getUncheckedKeys();
   if (uncheckedCount)
     state.removeUncheckedKeys();
-  const status = state.save();
+  const status = await state.save();
   snapshot.fileDeleted = status.deleted;
   snapshot.added = state.added;
   snapshot.matched = state.matched;
@@ -3091,7 +3147,7 @@ const SnapshotPlugin = (chai, utils) => {
   }
   utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function(inlineSnapshot, message) {
     const expected = utils.flag(this, "object");
-    getSnapshotClient().assert(expected, message, inlineSnapshot);
+    getSnapshotClient().assert(expected, message, true, inlineSnapshot);
   });
 };
 
@@ -3200,238 +3256,6 @@ var matcherUtils = /*#__PURE__*/Object.freeze({
   diff: diff
 });
 
-const isObject = (val) => toString.call(val) === "[object Object]";
-function equals(a, b, customTesters, strictCheck) {
-  customTesters = customTesters || [];
-  return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
-}
-function isAsymmetric(obj) {
-  return !!obj && isA("Function", obj.asymmetricMatch);
-}
-function hasAsymmetric(obj, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(obj))
-    return false;
-  seen.add(obj);
-  if (isAsymmetric(obj))
-    return true;
-  if (Array.isArray(obj))
-    return obj.some((i) => hasAsymmetric(i, seen));
-  if (obj instanceof Set)
-    return Array.from(obj).some((i) => hasAsymmetric(i, seen));
-  if (isObject(obj))
-    return Object.values(obj).some((v) => hasAsymmetric(v, seen));
-  return false;
-}
-function asymmetricMatch(a, b) {
-  const asymmetricA = isAsymmetric(a);
-  const asymmetricB = isAsymmetric(b);
-  if (asymmetricA && asymmetricB)
-    return void 0;
-  if (asymmetricA)
-    return a.asymmetricMatch(b);
-  if (asymmetricB)
-    return b.asymmetricMatch(a);
-}
-function eq(a, b, aStack, bStack, customTesters, hasKey2) {
-  let result = true;
-  const asymmetricResult = asymmetricMatch(a, b);
-  if (asymmetricResult !== void 0)
-    return asymmetricResult;
-  for (let i = 0; i < customTesters.length; i++) {
-    const customTesterResult = customTesters[i](a, b);
-    if (customTesterResult !== void 0)
-      return customTesterResult;
-  }
-  if (a instanceof Error && b instanceof Error)
-    return a.message === b.message;
-  if (Object.is(a, b))
-    return true;
-  if (a === null || b === null)
-    return a === b;
-  const className = Object.prototype.toString.call(a);
-  if (className !== Object.prototype.toString.call(b))
-    return false;
-  switch (className) {
-    case "[object Boolean]":
-    case "[object String]":
-    case "[object Number]":
-      if (typeof a !== typeof b) {
-        return false;
-      } else if (typeof a !== "object" && typeof b !== "object") {
-        return Object.is(a, b);
-      } else {
-        return Object.is(a.valueOf(), b.valueOf());
-      }
-    case "[object Date]":
-      return +a === +b;
-    case "[object RegExp]":
-      return a.source === b.source && a.flags === b.flags;
-  }
-  if (typeof a !== "object" || typeof b !== "object")
-    return false;
-  if (isDomNode(a) && isDomNode(b))
-    return a.isEqualNode(b);
-  let length = aStack.length;
-  while (length--) {
-    if (aStack[length] === a)
-      return bStack[length] === b;
-    else if (bStack[length] === b)
-      return false;
-  }
-  aStack.push(a);
-  bStack.push(b);
-  if (className === "[object Array]" && a.length !== b.length)
-    return false;
-  const aKeys = keys(a, hasKey2);
-  let key;
-  let size = aKeys.length;
-  if (keys(b, hasKey2).length !== size)
-    return false;
-  while (size--) {
-    key = aKeys[size];
-    result = hasKey2(b, key) && eq(a[key], b[key], aStack, bStack, customTesters, hasKey2);
-    if (!result)
-      return false;
-  }
-  aStack.pop();
-  bStack.pop();
-  return result;
-}
-function keys(obj, hasKey2) {
-  const keys2 = [];
-  for (const key in obj) {
-    if (hasKey2(obj, key))
-      keys2.push(key);
-  }
-  return keys2.concat(Object.getOwnPropertySymbols(obj).filter((symbol) => Object.getOwnPropertyDescriptor(obj, symbol).enumerable));
-}
-function hasDefinedKey(obj, key) {
-  return hasKey(obj, key) && obj[key] !== void 0;
-}
-function hasKey(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-}
-function isA(typeName, value) {
-  return Object.prototype.toString.apply(value) === `[object ${typeName}]`;
-}
-function isDomNode(obj) {
-  return obj !== null && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string" && typeof obj.isEqualNode === "function";
-}
-const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
-const IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
-const IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";
-function isImmutableUnorderedKeyed(maybeKeyed) {
-  return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL] && !maybeKeyed[IS_ORDERED_SENTINEL]);
-}
-function isImmutableUnorderedSet(maybeSet) {
-  return !!(maybeSet && maybeSet[IS_SET_SENTINEL] && !maybeSet[IS_ORDERED_SENTINEL]);
-}
-const IteratorSymbol = Symbol.iterator;
-const hasIterator = (object) => !!(object != null && object[IteratorSymbol]);
-const iterableEquality = (a, b, aStack = [], bStack = []) => {
-  if (typeof a !== "object" || typeof b !== "object" || Array.isArray(a) || Array.isArray(b) || !hasIterator(a) || !hasIterator(b))
-    return void 0;
-  if (a.constructor !== b.constructor)
-    return false;
-  let length = aStack.length;
-  while (length--) {
-    if (aStack[length] === a)
-      return bStack[length] === b;
-  }
-  aStack.push(a);
-  bStack.push(b);
-  const iterableEqualityWithStack = (a2, b2) => iterableEquality(a2, b2, [...aStack], [...bStack]);
-  if (a.size !== void 0) {
-    if (a.size !== b.size) {
-      return false;
-    } else if (isA("Set", a) || isImmutableUnorderedSet(a)) {
-      let allFound = true;
-      for (const aValue of a) {
-        if (!b.has(aValue)) {
-          let has = false;
-          for (const bValue of b) {
-            const isEqual = equals(aValue, bValue, [iterableEqualityWithStack]);
-            if (isEqual === true)
-              has = true;
-          }
-          if (has === false) {
-            allFound = false;
-            break;
-          }
-        }
-      }
-      aStack.pop();
-      bStack.pop();
-      return allFound;
-    } else if (isA("Map", a) || isImmutableUnorderedKeyed(a)) {
-      let allFound = true;
-      for (const aEntry of a) {
-        if (!b.has(aEntry[0]) || !equals(aEntry[1], b.get(aEntry[0]), [iterableEqualityWithStack])) {
-          let has = false;
-          for (const bEntry of b) {
-            const matchedKey = equals(aEntry[0], bEntry[0], [
-              iterableEqualityWithStack
-            ]);
-            let matchedValue = false;
-            if (matchedKey === true) {
-              matchedValue = equals(aEntry[1], bEntry[1], [
-                iterableEqualityWithStack
-              ]);
-            }
-            if (matchedValue === true)
-              has = true;
-          }
-          if (has === false) {
-            allFound = false;
-            break;
-          }
-        }
-      }
-      aStack.pop();
-      bStack.pop();
-      return allFound;
-    }
-  }
-  const bIterator = b[IteratorSymbol]();
-  for (const aValue of a) {
-    const nextB = bIterator.next();
-    if (nextB.done || !equals(aValue, nextB.value, [iterableEqualityWithStack]))
-      return false;
-  }
-  if (!bIterator.next().done)
-    return false;
-  aStack.pop();
-  bStack.pop();
-  return true;
-};
-const hasPropertyInObject = (object, key) => {
-  const shouldTerminate = !object || typeof object !== "object" || object === Object.prototype;
-  if (shouldTerminate)
-    return false;
-  return Object.prototype.hasOwnProperty.call(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
-};
-const isObjectWithKeys = (a) => isObject(a) && !(a instanceof Error) && !(a instanceof Array) && !(a instanceof Date);
-const subsetEquality = (object, subset) => {
-  const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object2, subset2) => {
-    if (!isObjectWithKeys(subset2))
-      return void 0;
-    return Object.keys(subset2).every((key) => {
-      if (isObjectWithKeys(subset2[key])) {
-        if (seenReferences.has(subset2[key]))
-          return equals(object2[key], subset2[key], [iterableEquality]);
-        seenReferences.set(subset2[key], true);
-      }
-      const result = object2 != null && hasPropertyInObject(object2, key) && equals(object2[key], subset2[key], [
-        iterableEquality,
-        subsetEqualityWithContext(seenReferences)
-      ]);
-      seenReferences.delete(subset2[key]);
-      return result;
-    });
-  };
-  return subsetEqualityWithContext()(object, subset);
-};
-
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -3499,213 +3323,11 @@ const JestExtend = (chai2, utils) => {
   });
 };
 
-const JestChaiExpect = (chai, utils) => {
-  function def(name, fn) {
-    const addMethod = (n) => {
-      utils.addMethod(chai.Assertion.prototype, n, fn);
-    };
-    if (Array.isArray(name))
-      name.forEach((n) => addMethod(n));
-    else
-      addMethod(name);
-  }
-  const chaiEqual = chai.Assertion.prototype.equal;
-  def("chaiEqual", function(...args) {
-    return chaiEqual.apply(this, args);
-  });
-  utils.overwriteMethod(chai.Assertion.prototype, "equal", (_super) => {
-    return function(...args) {
-      const expected = args[0];
-      const actual = utils.flag(this, "object");
-      if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected, void 0, true), "not match with #{act}", "should not match with #{act}", actual, expected);
-      } else {
-        _super.apply(this, args);
-      }
-    };
-  });
-  utils.overwriteMethod(chai.Assertion.prototype, "eql", (_super) => {
-    return function(...args) {
-      const expected = args[0];
-      const actual = utils.flag(this, "object");
-      if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected), "not match with #{exp}", "should not match with #{exp}", actual, expected);
-      } else {
-        _super.apply(this, args);
-      }
-    };
-  });
-  def("toEqual", function(expected) {
-    return this.eql(expected);
-  });
-  def("toStrictEqual", function(expected) {
-    return this.chaiEqual(expected);
-  });
-  def("toBe", function(expected) {
-    return this.equal(expected);
-  });
-  def("toMatchObject", function(expected) {
-    return this.containSubset(expected);
-  });
-  def("toMatch", function(expected) {
-    if (typeof expected === "string")
-      return this.include(expected);
-    else
-      return this.match(expected);
-  });
-  def("toContain", function(item) {
-    return this.contain(item);
-  });
-  def("toContainEqual", function(expected) {
-    const obj = utils.flag(this, "object");
-    const index = Array.from(obj).findIndex((item) => {
-      try {
-        chai.assert.deepEqual(item, expected);
-      } catch {
-        return false;
-      }
-      return true;
-    });
-    this.assert(index !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
-  });
-  def("toBeTruthy", function() {
-    const obj = utils.flag(this, "object");
-    this.assert(Boolean(obj), "expected #{this} to be truthy", "expected #{this} to not be truthy", obj);
-  });
-  def("toBeFalsy", function() {
-    const obj = utils.flag(this, "object");
-    this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", obj);
-  });
-  def("toBeGreaterThan", function(expected) {
-    return this.to.greaterThan(expected);
-  });
-  def("toBeGreaterThanOrEqual", function(expected) {
-    return this.to.greaterThanOrEqual(expected);
-  });
-  def("toBeLessThan", function(expected) {
-    return this.to.lessThan(expected);
-  });
-  def("toBeLessThanOrEqual", function(expected) {
-    return this.to.lessThanOrEqual(expected);
-  });
-  def("toBeNaN", function() {
-    return this.be.NaN;
-  });
-  def("toBeUndefined", function() {
-    return this.be.undefined;
-  });
-  def("toBeNull", function() {
-    return this.be.null;
-  });
-  def("toBeDefined", function() {
-    return this.not.be.undefined;
-  });
-  def("toBeInstanceOf", function(obj) {
-    return this.instanceOf(obj);
-  });
-  def("toHaveLength", function(length) {
-    return this.have.length(length);
-  });
-  def("toHaveProperty", function(...args) {
-    return this.have.deep.nested.property(...args);
-  });
-  def("toBeCloseTo", function(number, numDigits = 2) {
-    utils.expectTypes(this, ["number"]);
-    return this.closeTo(number, numDigits);
-  });
-  function isSpy(putativeSpy) {
-    return typeof putativeSpy === "function" && "__isSpy" in putativeSpy && putativeSpy.__isSpy;
-  }
-  const assertIsMock = (assertion) => {
-    if (!isSpy(assertion._obj))
-      throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
-  };
-  const getSpy = (assertion) => {
-    assertIsMock(assertion);
-    return assertion._obj;
-  };
-  def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
-    const spy = getSpy(this);
-    return this.assert(spy.callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number, spy.callCount);
-  });
-  def("toHaveBeenCalledOnce", function() {
-    const spy = getSpy(this);
-    return this.assert(spy.callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1, spy.callCount);
-  });
-  def(["toHaveBeenCalled", "toBeCalled"], function() {
-    const spy = getSpy(this);
-    return this.assert(spy.called, "expected spy to be called at least once", "expected spy to not be called at all", true, spy.called);
-  });
-  def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
-    const spy = getSpy(this);
-    const pass = spy.calls.some((callArg) => equals(callArg, args));
-    return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args, spy.calls);
-  });
-  const ordinalOf = (i) => {
-    const j = i % 10;
-    const k = i % 100;
-    if (j === 1 && k !== 11)
-      return `${i}st`;
-    if (j === 2 && k !== 12)
-      return `${i}nd`;
-    if (j === 3 && k !== 13)
-      return `${i}rd`;
-    return `${i}th`;
-  };
-  def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
-    const spy = getSpy(this);
-    const nthCall = spy.calls[times - 1];
-    this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
-  });
-  def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
-    const spy = getSpy(this);
-    const lastCall = spy.calls[spy.calls.length - 1];
-    this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
-  });
-  def(["toThrow", "toThrowError"], function(expected) {
-    const negate = utils.flag(this, "negate");
-    if (negate)
-      this.not.to.throw(expected);
-    else
-      this.to.throw(expected);
-  });
-  def(["toHaveReturned", "toReturn"], function() {
-    const spy = getSpy(this);
-    const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
-    this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
-  });
-  def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
-    const spy = getSpy(this);
-    const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
-    this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
-  });
-  def(["toHaveReturnedWith", "toReturnWith"], function(value) {
-    const spy = getSpy(this);
-    const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
-    this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
-  });
-  def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
-    const spy = getSpy(this);
-    const lastResult = spy.returns[spy.returns.length - 1];
-    const pass = equals(lastResult, value);
-    this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
-  });
-  def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
-    const spy = getSpy(this);
-    const isNot = utils.flag(this, "negate");
-    const [callType, callResult] = spy.results[nthCall - 1];
-    const ordinalCall = `${ordinalOf(nthCall)} call`;
-    if (!isNot && callType === "error")
-      chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
-    const nthCallReturn = equals(callResult, value);
-    this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
-  });
-};
-
 class AsymmetricMatcher {
   constructor(sample, inverse = false) {
     this.sample = sample;
     this.inverse = inverse;
+    this.$$typeof = Symbol.for("jest.asymmetricMatcher");
   }
   getMatcherContext() {
     return {
@@ -3906,7 +3528,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-e0d00047.js')).registerApiGlobally();
+    (await import('./global-75208c77.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3991,7 +3613,7 @@ async function collectTests(paths, config) {
   for (const filepath of paths) {
     const file = {
       id: nanoid(),
-      name: basename(filepath),
+      name: relative(config.root, filepath),
       type: "suite",
       mode: "run",
       computeMode: "serial",
@@ -4053,7 +3675,11 @@ async function runTest(test) {
   process.__vitest_worker__.current = test;
   try {
     await callSuiteHook(test.suite, "beforeEach", [test, test.suite]);
+    setState({ assertionCalls: 0, expectedAssertionsNumber: null, expectedAssertionsNumberError: null });
     await getFn(test)();
+    const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberError } = getState();
+    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
+      throw expectedAssertionsNumberError;
     test.result.state = "pass";
   } catch (e) {
     test.result.state = "fail";