@vitest/eslint-plugin/dist/index.js

ESLint plugin for Vitest

import { createRequire } from "node:module";
import { AST_NODE_TYPES, AST_TOKEN_TYPES, ESLintUtils } from "@typescript-eslint/utils";
import { isAbsolute, posix } from "node:path";
import { DefinitionType } from "@typescript-eslint/scope-manager";

//#region package.json
var version = "1.6.6";

//#endregion
//#region src/utils/index.ts
const createEslintRule = ESLintUtils.RuleCreator((name) => `https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/${name}.md`);
const joinNames = (a, b) => a && b ? `${a}.${b}` : null;
const isFunction = (node) => node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.ArrowFunctionExpression;
function getNodeName(node) {
	if (isSupportedAccessor(node)) return getAccessorValue(node);
	switch (node.type) {
		case AST_NODE_TYPES.TaggedTemplateExpression: return getNodeName(node.tag);
		case AST_NODE_TYPES.MemberExpression: return joinNames(getNodeName(node.object), getNodeName(node.property));
		case AST_NODE_TYPES.NewExpression:
		case AST_NODE_TYPES.CallExpression: return getNodeName(node.callee);
	}
	return null;
}
const isSupportedAccessor = (node, value) => {
	return isIdentifier(node, value) || isStringNode(node, value);
};
/**
* Checks if the given `node` is an `Identifier`.
*
* If a `name` is provided, & the `node` is an `Identifier`,
* the `name` will be compared to that of the `identifier`.
*/
const isIdentifier = (node, name) => {
	return node.type === AST_NODE_TYPES.Identifier && (name === void 0 || node.name === name);
};
/**
* Checks if the given `node` is a `TemplateLiteral`.
*
* Complex `TemplateLiteral`s are not considered specific, and so will return `false`.
*
* If a `value` is provided & the `node` is a `TemplateLiteral`,
* the `value` will be compared to that of the `TemplateLiteral`.
*/
const isTemplateLiteral = (node, value) => {
	return node.type === AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && (value === void 0 || node.quasis[0].value.raw === value);
};
/**
* Checks if the given `node` is a `StringLiteral`.
*
* If a `value` is provided & the `node` is a `StringLiteral`,
* the `value` will be compared to that of the `StringLiteral`.
*/
const isStringLiteral = (node, value) => node.type === AST_NODE_TYPES.Literal && typeof node.value === "string" && (value === void 0 || node.value === value);
/**
* Checks if the given `node` is a {@link StringNode}.
*/
const isStringNode = (node, specifics) => isStringLiteral(node, specifics) || isTemplateLiteral(node, specifics);
/**
* Gets the value of the given `AccessorNode`,
* account for the different node types.
*/
const getAccessorValue = (accessor) => accessor.type === AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
/**
* Gets the value of the given `StringNode`.
*
* If the `node` is a `TemplateLiteral`, the `raw` value is used;
* otherwise, `value` is returned instead.
*/
const getStringValue = (node) => node?.type === AST_NODE_TYPES.TemplateLiteral ? node.quasis[0].value.raw : node?.value;
const replaceAccessorFixer = (fixer, node, text) => {
	return fixer.replaceText(node, node.type === AST_NODE_TYPES.Identifier ? text : `'${text}'`);
};
const removeExtraArgumentsFixer = (fixer, context, func, from) => {
	const firstArg = func.arguments[from];
	const lastArg = func.arguments[func.arguments.length - 1];
	const { sourceCode } = context;
	let tokenAfterLastParam = sourceCode.getTokenAfter(lastArg);
	if (tokenAfterLastParam.value === ",") tokenAfterLastParam = sourceCode.getTokenAfter(tokenAfterLastParam);
	return fixer.removeRange([firstArg.range[0], tokenAfterLastParam.range[0]]);
};
const isParsedInstanceOfMatcherCall = (expectFnCall, classArg) => {
	return getAccessorValue(expectFnCall.matcher) === "toBeInstanceOf" && expectFnCall.args.length === 1 && isSupportedAccessor(expectFnCall.args[0], classArg);
};

//#endregion
//#region src/utils/require.ts
const require = createRequire(import.meta.url);

//#endregion
//#region src/utils/types.ts
let UtilName = /* @__PURE__ */ function(UtilName$1) {
	UtilName$1["vi"] = "vi";
	UtilName$1["vitest"] = "vitest";
	return UtilName$1;
}({});
let DescribeAlias = /* @__PURE__ */ function(DescribeAlias$1) {
	DescribeAlias$1["describe"] = "describe";
	DescribeAlias$1["fdescribe"] = "fdescribe";
	DescribeAlias$1["xdescribe"] = "xdescribe";
	return DescribeAlias$1;
}({});
let TestCaseName = /* @__PURE__ */ function(TestCaseName$1) {
	TestCaseName$1["fit"] = "fit";
	TestCaseName$1["it"] = "it";
	TestCaseName$1["test"] = "test";
	TestCaseName$1["xit"] = "xit";
	TestCaseName$1["xtest"] = "xtest";
	TestCaseName$1["bench"] = "bench";
	return TestCaseName$1;
}({});
let HookName = /* @__PURE__ */ function(HookName$1) {
	HookName$1["beforeAll"] = "beforeAll";
	HookName$1["beforeEach"] = "beforeEach";
	HookName$1["afterAll"] = "afterAll";
	HookName$1["afterEach"] = "afterEach";
	return HookName$1;
}({});
let ModifierName = /* @__PURE__ */ function(ModifierName$1) {
	ModifierName$1["to"] = "to";
	ModifierName$1["have"] = "have";
	ModifierName$1["not"] = "not";
	ModifierName$1["rejects"] = "rejects";
	ModifierName$1["resolves"] = "resolves";
	ModifierName$1["returns"] = "returns";
	ModifierName$1["branded"] = "branded";
	ModifierName$1["asserts"] = "asserts";
	ModifierName$1["constructorParameters"] = "constructorParameters";
	ModifierName$1["parameters"] = "parameters";
	ModifierName$1["thisParameter"] = "thisParameter";
	ModifierName$1["guards"] = "guards";
	ModifierName$1["instance"] = "instance";
	ModifierName$1["items"] = "items";
	return ModifierName$1;
}({});
let EqualityMatcher = /* @__PURE__ */ function(EqualityMatcher$1) {
	EqualityMatcher$1["toBe"] = "toBe";
	EqualityMatcher$1["toEqual"] = "toEqual";
	EqualityMatcher$1["toStrictEqual"] = "toStrictEqual";
	return EqualityMatcher$1;
}({});
function isClassOrFunctionType(type) {
	if (type.getCallSignatures().length > 0) return true;
	const ts = require("typescript");
	return type.getSymbol()?.getDeclarations()?.some((declaration) => ts.isArrowFunction(declaration) || ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration) || ts.isFunctionDeclaration(declaration) || ts.isFunctionExpression(declaration) || ts.isMethodDeclaration(declaration) || ts.isFunctionTypeNode(declaration)) ?? false;
}

//#endregion
//#region src/utils/valid-vitest-fn-call-chains.ts
const ValidVitestFnCallChains = new Set([
	"beforeEach",
	"beforeAll",
	"afterEach",
	"afterAll",
	"it",
	"it.extend",
	"it.scoped",
	"it.skip",
	"it.only",
	"it.concurrent",
	"it.sequential",
	"it.todo",
	"it.fails",
	"it.skipIf",
	"it.runIf",
	"it.each",
	"it.for",
	"it.skip.only",
	"it.skip.concurrent",
	"it.skip.sequential",
	"it.skip.todo",
	"it.skip.fails",
	"it.only.skip",
	"it.only.concurrent",
	"it.only.sequential",
	"it.only.todo",
	"it.only.fails",
	"it.concurrent.skip",
	"it.concurrent.only",
	"it.concurrent.sequential",
	"it.concurrent.todo",
	"it.concurrent.fails",
	"it.sequential.skip",
	"it.sequential.only",
	"it.sequential.concurrent",
	"it.sequential.todo",
	"it.sequential.fails",
	"it.todo.skip",
	"it.todo.only",
	"it.todo.concurrent",
	"it.todo.sequential",
	"it.todo.fails",
	"it.fails.skip",
	"it.fails.only",
	"it.fails.concurrent",
	"it.fails.sequential",
	"it.fails.todo",
	"it.skipIf.skip",
	"it.skipIf.only",
	"it.skipIf.concurrent",
	"it.skipIf.sequential",
	"it.skipIf.todo",
	"it.skipIf.fails",
	"it.runIf.skip",
	"it.runIf.only",
	"it.runIf.concurrent",
	"it.runIf.sequential",
	"it.runIf.todo",
	"it.runIf.fails",
	"it.skip.each",
	"it.only.each",
	"it.concurrent.each",
	"it.sequential.each",
	"it.todo.each",
	"it.fails.each",
	"it.skip.for",
	"it.only.for",
	"it.concurrent.for",
	"it.sequential.for",
	"it.todo.for",
	"it.fails.for",
	"it.skipIf.each",
	"it.skipIf.for",
	"it.runIf.each",
	"it.runIf.for",
	"it.skip.only.concurrent",
	"it.skip.only.sequential",
	"it.skip.only.todo",
	"it.skip.only.fails",
	"it.skip.concurrent.only",
	"it.skip.concurrent.sequential",
	"it.skip.concurrent.todo",
	"it.skip.concurrent.fails",
	"it.skip.sequential.only",
	"it.skip.sequential.concurrent",
	"it.skip.sequential.todo",
	"it.skip.sequential.fails",
	"it.skip.todo.only",
	"it.skip.todo.concurrent",
	"it.skip.todo.sequential",
	"it.skip.todo.fails",
	"it.skip.fails.only",
	"it.skip.fails.concurrent",
	"it.skip.fails.sequential",
	"it.skip.fails.todo",
	"it.only.skip.concurrent",
	"it.only.skip.sequential",
	"it.only.skip.todo",
	"it.only.skip.fails",
	"it.only.concurrent.skip",
	"it.only.concurrent.sequential",
	"it.only.concurrent.todo",
	"it.only.concurrent.fails",
	"it.only.sequential.skip",
	"it.only.sequential.concurrent",
	"it.only.sequential.todo",
	"it.only.sequential.fails",
	"it.only.todo.skip",
	"it.only.todo.concurrent",
	"it.only.todo.sequential",
	"it.only.todo.fails",
	"it.only.fails.skip",
	"it.only.fails.concurrent",
	"it.only.fails.sequential",
	"it.only.fails.todo",
	"it.concurrent.skip.only",
	"it.concurrent.skip.sequential",
	"it.concurrent.skip.todo",
	"it.concurrent.skip.fails",
	"it.concurrent.only.skip",
	"it.concurrent.only.sequential",
	"it.concurrent.only.todo",
	"it.concurrent.only.fails",
	"it.concurrent.sequential.skip",
	"it.concurrent.sequential.only",
	"it.concurrent.sequential.todo",
	"it.concurrent.sequential.fails",
	"it.concurrent.todo.skip",
	"it.concurrent.todo.only",
	"it.concurrent.todo.sequential",
	"it.concurrent.todo.fails",
	"it.concurrent.fails.skip",
	"it.concurrent.fails.only",
	"it.concurrent.fails.sequential",
	"it.concurrent.fails.todo",
	"it.sequential.skip.only",
	"it.sequential.skip.concurrent",
	"it.sequential.skip.todo",
	"it.sequential.skip.fails",
	"it.sequential.only.skip",
	"it.sequential.only.concurrent",
	"it.sequential.only.todo",
	"it.sequential.only.fails",
	"it.sequential.concurrent.skip",
	"it.sequential.concurrent.only",
	"it.sequential.concurrent.todo",
	"it.sequential.concurrent.fails",
	"it.sequential.todo.skip",
	"it.sequential.todo.only",
	"it.sequential.todo.concurrent",
	"it.sequential.todo.fails",
	"it.sequential.fails.skip",
	"it.sequential.fails.only",
	"it.sequential.fails.concurrent",
	"it.sequential.fails.todo",
	"it.todo.skip.only",
	"it.todo.skip.concurrent",
	"it.todo.skip.sequential",
	"it.todo.skip.fails",
	"it.todo.only.skip",
	"it.todo.only.concurrent",
	"it.todo.only.sequential",
	"it.todo.only.fails",
	"it.todo.concurrent.skip",
	"it.todo.concurrent.only",
	"it.todo.concurrent.sequential",
	"it.todo.concurrent.fails",
	"it.todo.sequential.skip",
	"it.todo.sequential.only",
	"it.todo.sequential.concurrent",
	"it.todo.sequential.fails",
	"it.todo.fails.skip",
	"it.todo.fails.only",
	"it.todo.fails.concurrent",
	"it.todo.fails.sequential",
	"it.fails.skip.only",
	"it.fails.skip.concurrent",
	"it.fails.skip.sequential",
	"it.fails.skip.todo",
	"it.fails.only.skip",
	"it.fails.only.concurrent",
	"it.fails.only.sequential",
	"it.fails.only.todo",
	"it.fails.concurrent.skip",
	"it.fails.concurrent.only",
	"it.fails.concurrent.sequential",
	"it.fails.concurrent.todo",
	"it.fails.sequential.skip",
	"it.fails.sequential.only",
	"it.fails.sequential.concurrent",
	"it.fails.sequential.todo",
	"it.fails.todo.skip",
	"it.fails.todo.only",
	"it.fails.todo.concurrent",
	"it.fails.todo.sequential",
	"it.skipIf.skip.only",
	"it.skipIf.skip.concurrent",
	"it.skipIf.skip.sequential",
	"it.skipIf.skip.todo",
	"it.skipIf.skip.fails",
	"it.skipIf.only.skip",
	"it.skipIf.only.concurrent",
	"it.skipIf.only.sequential",
	"it.skipIf.only.todo",
	"it.skipIf.only.fails",
	"it.skipIf.concurrent.skip",
	"it.skipIf.concurrent.only",
	"it.skipIf.concurrent.sequential",
	"it.skipIf.concurrent.todo",
	"it.skipIf.concurrent.fails",
	"it.skipIf.sequential.skip",
	"it.skipIf.sequential.only",
	"it.skipIf.sequential.concurrent",
	"it.skipIf.sequential.todo",
	"it.skipIf.sequential.fails",
	"it.skipIf.todo.skip",
	"it.skipIf.todo.only",
	"it.skipIf.todo.concurrent",
	"it.skipIf.todo.sequential",
	"it.skipIf.todo.fails",
	"it.skipIf.fails.skip",
	"it.skipIf.fails.only",
	"it.skipIf.fails.concurrent",
	"it.skipIf.fails.sequential",
	"it.skipIf.fails.todo",
	"it.runIf.skip.only",
	"it.runIf.skip.concurrent",
	"it.runIf.skip.sequential",
	"it.runIf.skip.todo",
	"it.runIf.skip.fails",
	"it.runIf.only.skip",
	"it.runIf.only.concurrent",
	"it.runIf.only.sequential",
	"it.runIf.only.todo",
	"it.runIf.only.fails",
	"it.runIf.concurrent.skip",
	"it.runIf.concurrent.only",
	"it.runIf.concurrent.sequential",
	"it.runIf.concurrent.todo",
	"it.runIf.concurrent.fails",
	"it.runIf.sequential.skip",
	"it.runIf.sequential.only",
	"it.runIf.sequential.concurrent",
	"it.runIf.sequential.todo",
	"it.runIf.sequential.fails",
	"it.runIf.todo.skip",
	"it.runIf.todo.only",
	"it.runIf.todo.concurrent",
	"it.runIf.todo.sequential",
	"it.runIf.todo.fails",
	"it.runIf.fails.skip",
	"it.runIf.fails.only",
	"it.runIf.fails.concurrent",
	"it.runIf.fails.sequential",
	"it.runIf.fails.todo",
	"it.skip.only.each",
	"it.skip.concurrent.each",
	"it.skip.sequential.each",
	"it.skip.todo.each",
	"it.skip.fails.each",
	"it.only.skip.each",
	"it.only.concurrent.each",
	"it.only.sequential.each",
	"it.only.todo.each",
	"it.only.fails.each",
	"it.concurrent.skip.each",
	"it.concurrent.only.each",
	"it.concurrent.sequential.each",
	"it.concurrent.todo.each",
	"it.concurrent.fails.each",
	"it.sequential.skip.each",
	"it.sequential.only.each",
	"it.sequential.concurrent.each",
	"it.sequential.todo.each",
	"it.sequential.fails.each",
	"it.todo.skip.each",
	"it.todo.only.each",
	"it.todo.concurrent.each",
	"it.todo.sequential.each",
	"it.todo.fails.each",
	"it.fails.skip.each",
	"it.fails.only.each",
	"it.fails.concurrent.each",
	"it.fails.sequential.each",
	"it.fails.todo.each",
	"it.skip.only.for",
	"it.skip.concurrent.for",
	"it.skip.sequential.for",
	"it.skip.todo.for",
	"it.skip.fails.for",
	"it.only.skip.for",
	"it.only.concurrent.for",
	"it.only.sequential.for",
	"it.only.todo.for",
	"it.only.fails.for",
	"it.concurrent.skip.for",
	"it.concurrent.only.for",
	"it.concurrent.sequential.for",
	"it.concurrent.todo.for",
	"it.concurrent.fails.for",
	"it.sequential.skip.for",
	"it.sequential.only.for",
	"it.sequential.concurrent.for",
	"it.sequential.todo.for",
	"it.sequential.fails.for",
	"it.todo.skip.for",
	"it.todo.only.for",
	"it.todo.concurrent.for",
	"it.todo.sequential.for",
	"it.todo.fails.for",
	"it.fails.skip.for",
	"it.fails.only.for",
	"it.fails.concurrent.for",
	"it.fails.sequential.for",
	"it.fails.todo.for",
	"it.skipIf.skip.each",
	"it.skipIf.only.each",
	"it.skipIf.concurrent.each",
	"it.skipIf.sequential.each",
	"it.skipIf.todo.each",
	"it.skipIf.fails.each",
	"it.skipIf.skip.for",
	"it.skipIf.only.for",
	"it.skipIf.concurrent.for",
	"it.skipIf.sequential.for",
	"it.skipIf.todo.for",
	"it.skipIf.fails.for",
	"it.runIf.skip.each",
	"it.runIf.only.each",
	"it.runIf.concurrent.each",
	"it.runIf.sequential.each",
	"it.runIf.todo.each",
	"it.runIf.fails.each",
	"it.runIf.skip.for",
	"it.runIf.only.for",
	"it.runIf.concurrent.for",
	"it.runIf.sequential.for",
	"it.runIf.todo.for",
	"it.runIf.fails.for",
	"test",
	"test.extend",
	"test.scoped",
	"test.skip",
	"test.only",
	"test.concurrent",
	"test.sequential",
	"test.todo",
	"test.fails",
	"test.skipIf",
	"test.runIf",
	"test.each",
	"test.for",
	"test.skip.only",
	"test.skip.concurrent",
	"test.skip.sequential",
	"test.skip.todo",
	"test.skip.fails",
	"test.only.skip",
	"test.only.concurrent",
	"test.only.sequential",
	"test.only.todo",
	"test.only.fails",
	"test.concurrent.skip",
	"test.concurrent.only",
	"test.concurrent.sequential",
	"test.concurrent.todo",
	"test.concurrent.fails",
	"test.sequential.skip",
	"test.sequential.only",
	"test.sequential.concurrent",
	"test.sequential.todo",
	"test.sequential.fails",
	"test.todo.skip",
	"test.todo.only",
	"test.todo.concurrent",
	"test.todo.sequential",
	"test.todo.fails",
	"test.fails.skip",
	"test.fails.only",
	"test.fails.concurrent",
	"test.fails.sequential",
	"test.fails.todo",
	"test.skipIf.skip",
	"test.skipIf.only",
	"test.skipIf.concurrent",
	"test.skipIf.sequential",
	"test.skipIf.todo",
	"test.skipIf.fails",
	"test.runIf.skip",
	"test.runIf.only",
	"test.runIf.concurrent",
	"test.runIf.sequential",
	"test.runIf.todo",
	"test.runIf.fails",
	"test.skip.each",
	"test.only.each",
	"test.concurrent.each",
	"test.sequential.each",
	"test.todo.each",
	"test.fails.each",
	"test.skip.for",
	"test.only.for",
	"test.concurrent.for",
	"test.sequential.for",
	"test.todo.for",
	"test.fails.for",
	"test.skipIf.each",
	"test.skipIf.for",
	"test.runIf.each",
	"test.runIf.for",
	"test.skip.only.concurrent",
	"test.skip.only.sequential",
	"test.skip.only.todo",
	"test.skip.only.fails",
	"test.skip.concurrent.only",
	"test.skip.concurrent.sequential",
	"test.skip.concurrent.todo",
	"test.skip.concurrent.fails",
	"test.skip.sequential.only",
	"test.skip.sequential.concurrent",
	"test.skip.sequential.todo",
	"test.skip.sequential.fails",
	"test.skip.todo.only",
	"test.skip.todo.concurrent",
	"test.skip.todo.sequential",
	"test.skip.todo.fails",
	"test.skip.fails.only",
	"test.skip.fails.concurrent",
	"test.skip.fails.sequential",
	"test.skip.fails.todo",
	"test.only.skip.concurrent",
	"test.only.skip.sequential",
	"test.only.skip.todo",
	"test.only.skip.fails",
	"test.only.concurrent.skip",
	"test.only.concurrent.sequential",
	"test.only.concurrent.todo",
	"test.only.concurrent.fails",
	"test.only.sequential.skip",
	"test.only.sequential.concurrent",
	"test.only.sequential.todo",
	"test.only.sequential.fails",
	"test.only.todo.skip",
	"test.only.todo.concurrent",
	"test.only.todo.sequential",
	"test.only.todo.fails",
	"test.only.fails.skip",
	"test.only.fails.concurrent",
	"test.only.fails.sequential",
	"test.only.fails.todo",
	"test.concurrent.skip.only",
	"test.concurrent.skip.sequential",
	"test.concurrent.skip.todo",
	"test.concurrent.skip.fails",
	"test.concurrent.only.skip",
	"test.concurrent.only.sequential",
	"test.concurrent.only.todo",
	"test.concurrent.only.fails",
	"test.concurrent.sequential.skip",
	"test.concurrent.sequential.only",
	"test.concurrent.sequential.todo",
	"test.concurrent.sequential.fails",
	"test.concurrent.todo.skip",
	"test.concurrent.todo.only",
	"test.concurrent.todo.sequential",
	"test.concurrent.todo.fails",
	"test.concurrent.fails.skip",
	"test.concurrent.fails.only",
	"test.concurrent.fails.sequential",
	"test.concurrent.fails.todo",
	"test.sequential.skip.only",
	"test.sequential.skip.concurrent",
	"test.sequential.skip.todo",
	"test.sequential.skip.fails",
	"test.sequential.only.skip",
	"test.sequential.only.concurrent",
	"test.sequential.only.todo",
	"test.sequential.only.fails",
	"test.sequential.concurrent.skip",
	"test.sequential.concurrent.only",
	"test.sequential.concurrent.todo",
	"test.sequential.concurrent.fails",
	"test.sequential.todo.skip",
	"test.sequential.todo.only",
	"test.sequential.todo.concurrent",
	"test.sequential.todo.fails",
	"test.sequential.fails.skip",
	"test.sequential.fails.only",
	"test.sequential.fails.concurrent",
	"test.sequential.fails.todo",
	"test.todo.skip.only",
	"test.todo.skip.concurrent",
	"test.todo.skip.sequential",
	"test.todo.skip.fails",
	"test.todo.only.skip",
	"test.todo.only.concurrent",
	"test.todo.only.sequential",
	"test.todo.only.fails",
	"test.todo.concurrent.skip",
	"test.todo.concurrent.only",
	"test.todo.concurrent.sequential",
	"test.todo.concurrent.fails",
	"test.todo.sequential.skip",
	"test.todo.sequential.only",
	"test.todo.sequential.concurrent",
	"test.todo.sequential.fails",
	"test.todo.fails.skip",
	"test.todo.fails.only",
	"test.todo.fails.concurrent",
	"test.todo.fails.sequential",
	"test.fails.skip.only",
	"test.fails.skip.concurrent",
	"test.fails.skip.sequential",
	"test.fails.skip.todo",
	"test.fails.only.skip",
	"test.fails.only.concurrent",
	"test.fails.only.sequential",
	"test.fails.only.todo",
	"test.fails.concurrent.skip",
	"test.fails.concurrent.only",
	"test.fails.concurrent.sequential",
	"test.fails.concurrent.todo",
	"test.fails.sequential.skip",
	"test.fails.sequential.only",
	"test.fails.sequential.concurrent",
	"test.fails.sequential.todo",
	"test.fails.todo.skip",
	"test.fails.todo.only",
	"test.fails.todo.concurrent",
	"test.fails.todo.sequential",
	"test.skipIf.skip.only",
	"test.skipIf.skip.concurrent",
	"test.skipIf.skip.sequential",
	"test.skipIf.skip.todo",
	"test.skipIf.skip.fails",
	"test.skipIf.only.skip",
	"test.skipIf.only.concurrent",
	"test.skipIf.only.sequential",
	"test.skipIf.only.todo",
	"test.skipIf.only.fails",
	"test.skipIf.concurrent.skip",
	"test.skipIf.concurrent.only",
	"test.skipIf.concurrent.sequential",
	"test.skipIf.concurrent.todo",
	"test.skipIf.concurrent.fails",
	"test.skipIf.sequential.skip",
	"test.skipIf.sequential.only",
	"test.skipIf.sequential.concurrent",
	"test.skipIf.sequential.todo",
	"test.skipIf.sequential.fails",
	"test.skipIf.todo.skip",
	"test.skipIf.todo.only",
	"test.skipIf.todo.concurrent",
	"test.skipIf.todo.sequential",
	"test.skipIf.todo.fails",
	"test.skipIf.fails.skip",
	"test.skipIf.fails.only",
	"test.skipIf.fails.concurrent",
	"test.skipIf.fails.sequential",
	"test.skipIf.fails.todo",
	"test.runIf.skip.only",
	"test.runIf.skip.concurrent",
	"test.runIf.skip.sequential",
	"test.runIf.skip.todo",
	"test.runIf.skip.fails",
	"test.runIf.only.skip",
	"test.runIf.only.concurrent",
	"test.runIf.only.sequential",
	"test.runIf.only.todo",
	"test.runIf.only.fails",
	"test.runIf.concurrent.skip",
	"test.runIf.concurrent.only",
	"test.runIf.concurrent.sequential",
	"test.runIf.concurrent.todo",
	"test.runIf.concurrent.fails",
	"test.runIf.sequential.skip",
	"test.runIf.sequential.only",
	"test.runIf.sequential.concurrent",
	"test.runIf.sequential.todo",
	"test.runIf.sequential.fails",
	"test.runIf.todo.skip",
	"test.runIf.todo.only",
	"test.runIf.todo.concurrent",
	"test.runIf.todo.sequential",
	"test.runIf.todo.fails",
	"test.runIf.fails.skip",
	"test.runIf.fails.only",
	"test.runIf.fails.concurrent",
	"test.runIf.fails.sequential",
	"test.runIf.fails.todo",
	"test.skip.only.each",
	"test.skip.concurrent.each",
	"test.skip.sequential.each",
	"test.skip.todo.each",
	"test.skip.fails.each",
	"test.only.skip.each",
	"test.only.concurrent.each",
	"test.only.sequential.each",
	"test.only.todo.each",
	"test.only.fails.each",
	"test.concurrent.skip.each",
	"test.concurrent.only.each",
	"test.concurrent.sequential.each",
	"test.concurrent.todo.each",
	"test.concurrent.fails.each",
	"test.sequential.skip.each",
	"test.sequential.only.each",
	"test.sequential.concurrent.each",
	"test.sequential.todo.each",
	"test.sequential.fails.each",
	"test.todo.skip.each",
	"test.todo.only.each",
	"test.todo.concurrent.each",
	"test.todo.sequential.each",
	"test.todo.fails.each",
	"test.fails.skip.each",
	"test.fails.only.each",
	"test.fails.concurrent.each",
	"test.fails.sequential.each",
	"test.fails.todo.each",
	"test.skip.only.for",
	"test.skip.concurrent.for",
	"test.skip.sequential.for",
	"test.skip.todo.for",
	"test.skip.fails.for",
	"test.only.skip.for",
	"test.only.concurrent.for",
	"test.only.sequential.for",
	"test.only.todo.for",
	"test.only.fails.for",
	"test.concurrent.skip.for",
	"test.concurrent.only.for",
	"test.concurrent.sequential.for",
	"test.concurrent.todo.for",
	"test.concurrent.fails.for",
	"test.sequential.skip.for",
	"test.sequential.only.for",
	"test.sequential.concurrent.for",
	"test.sequential.todo.for",
	"test.sequential.fails.for",
	"test.todo.skip.for",
	"test.todo.only.for",
	"test.todo.concurrent.for",
	"test.todo.sequential.for",
	"test.todo.fails.for",
	"test.fails.skip.for",
	"test.fails.only.for",
	"test.fails.concurrent.for",
	"test.fails.sequential.for",
	"test.fails.todo.for",
	"test.skipIf.skip.each",
	"test.skipIf.only.each",
	"test.skipIf.concurrent.each",
	"test.skipIf.sequential.each",
	"test.skipIf.todo.each",
	"test.skipIf.fails.each",
	"test.skipIf.skip.for",
	"test.skipIf.only.for",
	"test.skipIf.concurrent.for",
	"test.skipIf.sequential.for",
	"test.skipIf.todo.for",
	"test.skipIf.fails.for",
	"test.runIf.skip.each",
	"test.runIf.only.each",
	"test.runIf.concurrent.each",
	"test.runIf.sequential.each",
	"test.runIf.todo.each",
	"test.runIf.fails.each",
	"test.runIf.skip.for",
	"test.runIf.only.for",
	"test.runIf.concurrent.for",
	"test.runIf.sequential.for",
	"test.runIf.todo.for",
	"test.runIf.fails.for",
	"bench",
	"bench.skip",
	"bench.only",
	"bench.todo",
	"bench.skipIf",
	"bench.runIf",
	"bench.skip.only",
	"bench.skip.todo",
	"bench.only.skip",
	"bench.only.todo",
	"bench.todo.skip",
	"bench.todo.only",
	"bench.skipIf.skip",
	"bench.skipIf.only",
	"bench.skipIf.todo",
	"bench.runIf.skip",
	"bench.runIf.only",
	"bench.runIf.todo",
	"bench.skip.only.todo",
	"bench.skip.todo.only",
	"bench.only.skip.todo",
	"bench.only.todo.skip",
	"bench.todo.skip.only",
	"bench.todo.only.skip",
	"bench.skipIf.skip.only",
	"bench.skipIf.skip.todo",
	"bench.skipIf.only.skip",
	"bench.skipIf.only.todo",
	"bench.skipIf.todo.skip",
	"bench.skipIf.todo.only",
	"bench.runIf.skip.only",
	"bench.runIf.skip.todo",
	"bench.runIf.only.skip",
	"bench.runIf.only.todo",
	"bench.runIf.todo.skip",
	"bench.runIf.todo.only",
	"describe",
	"describe.skip",
	"describe.only",
	"describe.concurrent",
	"describe.sequential",
	"describe.shuffle",
	"describe.todo",
	"describe.skipIf",
	"describe.runIf",
	"describe.each",
	"describe.for",
	"describe.skip.only",
	"describe.skip.concurrent",
	"describe.skip.sequential",
	"describe.skip.shuffle",
	"describe.skip.todo",
	"describe.only.skip",
	"describe.only.concurrent",
	"describe.only.sequential",
	"describe.only.shuffle",
	"describe.only.todo",
	"describe.concurrent.skip",
	"describe.concurrent.only",
	"describe.concurrent.sequential",
	"describe.concurrent.shuffle",
	"describe.concurrent.todo",
	"describe.sequential.skip",
	"describe.sequential.only",
	"describe.sequential.concurrent",
	"describe.sequential.shuffle",
	"describe.sequential.todo",
	"describe.shuffle.skip",
	"describe.shuffle.only",
	"describe.shuffle.concurrent",
	"describe.shuffle.sequential",
	"describe.shuffle.todo",
	"describe.todo.skip",
	"describe.todo.only",
	"describe.todo.concurrent",
	"describe.todo.sequential",
	"describe.todo.shuffle",
	"describe.skipIf.skip",
	"describe.skipIf.only",
	"describe.skipIf.concurrent",
	"describe.skipIf.sequential",
	"describe.skipIf.shuffle",
	"describe.skipIf.todo",
	"describe.runIf.skip",
	"describe.runIf.only",
	"describe.runIf.concurrent",
	"describe.runIf.sequential",
	"describe.runIf.shuffle",
	"describe.runIf.todo",
	"describe.skip.each",
	"describe.only.each",
	"describe.concurrent.each",
	"describe.sequential.each",
	"describe.shuffle.each",
	"describe.todo.each",
	"describe.skip.for",
	"describe.only.for",
	"describe.concurrent.for",
	"describe.sequential.for",
	"describe.shuffle.for",
	"describe.todo.for",
	"describe.skipIf.each",
	"describe.skipIf.for",
	"describe.runIf.each",
	"describe.runIf.for",
	"describe.skip.only.concurrent",
	"describe.skip.only.sequential",
	"describe.skip.only.shuffle",
	"describe.skip.only.todo",
	"describe.skip.concurrent.only",
	"describe.skip.concurrent.sequential",
	"describe.skip.concurrent.shuffle",
	"describe.skip.concurrent.todo",
	"describe.skip.sequential.only",
	"describe.skip.sequential.concurrent",
	"describe.skip.sequential.shuffle",
	"describe.skip.sequential.todo",
	"describe.skip.shuffle.only",
	"describe.skip.shuffle.concurrent",
	"describe.skip.shuffle.sequential",
	"describe.skip.shuffle.todo",
	"describe.skip.todo.only",
	"describe.skip.todo.concurrent",
	"describe.skip.todo.sequential",
	"describe.skip.todo.shuffle",
	"describe.only.skip.concurrent",
	"describe.only.skip.sequential",
	"describe.only.skip.shuffle",
	"describe.only.skip.todo",
	"describe.only.concurrent.skip",
	"describe.only.concurrent.sequential",
	"describe.only.concurrent.shuffle",
	"describe.only.concurrent.todo",
	"describe.only.sequential.skip",
	"describe.only.sequential.concurrent",
	"describe.only.sequential.shuffle",
	"describe.only.sequential.todo",
	"describe.only.shuffle.skip",
	"describe.only.shuffle.concurrent",
	"describe.only.shuffle.sequential",
	"describe.only.shuffle.todo",
	"describe.only.todo.skip",
	"describe.only.todo.concurrent",
	"describe.only.todo.sequential",
	"describe.only.todo.shuffle",
	"describe.concurrent.skip.only",
	"describe.concurrent.skip.sequential",
	"describe.concurrent.skip.shuffle",
	"describe.concurrent.skip.todo",
	"describe.concurrent.only.skip",
	"describe.concurrent.only.sequential",
	"describe.concurrent.only.shuffle",
	"describe.concurrent.only.todo",
	"describe.concurrent.sequential.skip",
	"describe.concurrent.sequential.only",
	"describe.concurrent.sequential.shuffle",
	"describe.concurrent.sequential.todo",
	"describe.concurrent.shuffle.skip",
	"describe.concurrent.shuffle.only",
	"describe.concurrent.shuffle.sequential",
	"describe.concurrent.shuffle.todo",
	"describe.concurrent.todo.skip",
	"describe.concurrent.todo.only",
	"describe.concurrent.todo.sequential",
	"describe.concurrent.todo.shuffle",
	"describe.sequential.skip.only",
	"describe.sequential.skip.concurrent",
	"describe.sequential.skip.shuffle",
	"describe.sequential.skip.todo",
	"describe.sequential.only.skip",
	"describe.sequential.only.concurrent",
	"describe.sequential.only.shuffle",
	"describe.sequential.only.todo",
	"describe.sequential.concurrent.skip",
	"describe.sequential.concurrent.only",
	"describe.sequential.concurrent.shuffle",
	"describe.sequential.concurrent.todo",
	"describe.sequential.shuffle.skip",
	"describe.sequential.shuffle.only",
	"describe.sequential.shuffle.concurrent",
	"describe.sequential.shuffle.todo",
	"describe.sequential.todo.skip",
	"describe.sequential.todo.only",
	"describe.sequential.todo.concurrent",
	"describe.sequential.todo.shuffle",
	"describe.shuffle.skip.only",
	"describe.shuffle.skip.concurrent",
	"describe.shuffle.skip.sequential",
	"describe.shuffle.skip.todo",
	"describe.shuffle.only.skip",
	"describe.shuffle.only.concurrent",
	"describe.shuffle.only.sequential",
	"describe.shuffle.only.todo",
	"describe.shuffle.concurrent.skip",
	"describe.shuffle.concurrent.only",
	"describe.shuffle.concurrent.sequential",
	"describe.shuffle.concurrent.todo",
	"describe.shuffle.sequential.skip",
	"describe.shuffle.sequential.only",
	"describe.shuffle.sequential.concurrent",
	"describe.shuffle.sequential.todo",
	"describe.shuffle.todo.skip",
	"describe.shuffle.todo.only",
	"describe.shuffle.todo.concurrent",
	"describe.shuffle.todo.sequential",
	"describe.todo.skip.only",
	"describe.todo.skip.concurrent",
	"describe.todo.skip.sequential",
	"describe.todo.skip.shuffle",
	"describe.todo.only.skip",
	"describe.todo.only.concurrent",
	"describe.todo.only.sequential",
	"describe.todo.only.shuffle",
	"describe.todo.concurrent.skip",
	"describe.todo.concurrent.only",
	"describe.todo.concurrent.sequential",
	"describe.todo.concurrent.shuffle",
	"describe.todo.sequential.skip",
	"describe.todo.sequential.only",
	"describe.todo.sequential.concurrent",
	"describe.todo.sequential.shuffle",
	"describe.todo.shuffle.skip",
	"describe.todo.shuffle.only",
	"describe.todo.shuffle.concurrent",
	"describe.todo.shuffle.sequential",
	"describe.skipIf.skip.only",
	"describe.skipIf.skip.concurrent",
	"describe.skipIf.skip.sequential",
	"describe.skipIf.skip.shuffle",
	"describe.skipIf.skip.todo",
	"describe.skipIf.only.skip",
	"describe.skipIf.only.concurrent",
	"describe.skipIf.only.sequential",
	"describe.skipIf.only.shuffle",
	"describe.skipIf.only.todo",
	"describe.skipIf.concurrent.skip",
	"describe.skipIf.concurrent.only",
	"describe.skipIf.concurrent.sequential",
	"describe.skipIf.concurrent.shuffle",
	"describe.skipIf.concurrent.todo",
	"describe.skipIf.sequential.skip",
	"describe.skipIf.sequential.only",
	"describe.skipIf.sequential.concurrent",
	"describe.skipIf.sequential.shuffle",
	"describe.skipIf.sequential.todo",
	"describe.skipIf.shuffle.skip",
	"describe.skipIf.shuffle.only",
	"describe.skipIf.shuffle.concurrent",
	"describe.skipIf.shuffle.sequential",
	"describe.skipIf.shuffle.todo",
	"describe.skipIf.todo.skip",
	"describe.skipIf.todo.only",
	"describe.skipIf.todo.concurrent",
	"describe.skipIf.todo.sequential",
	"describe.skipIf.todo.shuffle",
	"describe.runIf.skip.only",
	"describe.runIf.skip.concurrent",
	"describe.runIf.skip.sequential",
	"describe.runIf.skip.shuffle",
	"describe.runIf.skip.todo",
	"describe.runIf.only.skip",
	"describe.runIf.only.concurrent",
	"describe.runIf.only.sequential",
	"describe.runIf.only.shuffle",
	"describe.runIf.only.todo",
	"describe.runIf.concurrent.skip",
	"describe.runIf.concurrent.only",
	"describe.runIf.concurrent.sequential",
	"describe.runIf.concurrent.shuffle",
	"describe.runIf.concurrent.todo",
	"describe.runIf.sequential.skip",
	"describe.runIf.sequential.only",
	"describe.runIf.sequential.concurrent",
	"describe.runIf.sequential.shuffle",
	"describe.runIf.sequential.todo",
	"describe.runIf.shuffle.skip",
	"describe.runIf.shuffle.only",
	"describe.runIf.shuffle.concurrent",
	"describe.runIf.shuffle.sequential",
	"describe.runIf.shuffle.todo",
	"describe.runIf.todo.skip",
	"describe.runIf.todo.only",
	"describe.runIf.todo.concurrent",
	"describe.runIf.todo.sequential",
	"describe.runIf.todo.shuffle",
	"describe.skip.only.each",
	"describe.skip.concurrent.each",
	"describe.skip.sequential.each",
	"describe.skip.shuffle.each",
	"describe.skip.todo.each",
	"describe.only.skip.each",
	"describe.only.concurrent.each",
	"describe.only.sequential.each",
	"describe.only.shuffle.each",
	"describe.only.todo.each",
	"describe.concurrent.skip.each",
	"describe.concurrent.only.each",
	"describe.concurrent.sequential.each",
	"describe.concurrent.shuffle.each",
	"describe.concurrent.todo.each",
	"describe.sequential.skip.each",
	"describe.sequential.only.each",
	"describe.sequential.concurrent.each",
	"describe.sequential.shuffle.each",
	"describe.sequential.todo.each",
	"describe.shuffle.skip.each",
	"describe.shuffle.only.each",
	"describe.shuffle.concurrent.each",
	"describe.shuffle.sequential.each",
	"describe.shuffle.todo.each",
	"describe.todo.skip.each",
	"describe.todo.only.each",
	"describe.todo.concurrent.each",
	"describe.todo.sequential.each",
	"describe.todo.shuffle.each",
	"describe.skip.only.for",
	"describe.skip.concurrent.for",
	"describe.skip.sequential.for",
	"describe.skip.shuffle.for",
	"describe.skip.todo.for",
	"describe.only.skip.for",
	"describe.only.concurrent.for",
	"describe.only.sequential.for",
	"describe.only.shuffle.for",
	"describe.only.todo.for",
	"describe.concurrent.skip.for",
	"describe.concurrent.only.for",
	"describe.concurrent.sequential.for",
	"describe.concurrent.shuffle.for",
	"describe.concurrent.todo.for",
	"describe.sequential.skip.for",
	"describe.sequential.only.for",
	"describe.sequential.concurrent.for",
	"describe.sequential.shuffle.for",
	"describe.sequential.todo.for",
	"describe.shuffle.skip.for",
	"describe.shuffle.only.for",
	"describe.shuffle.concurrent.for",
	"describe.shuffle.sequential.for",
	"describe.shuffle.todo.for",
	"describe.todo.skip.for",
	"describe.todo.only.for",
	"describe.todo.concurrent.for",
	"describe.todo.sequential.for",
	"describe.todo.shuffle.for",
	"describe.skipIf.skip.each",
	"describe.skipIf.only.each",
	"describe.skipIf.concurrent.each",
	"describe.skipIf.sequential.each",
	"describe.skipIf.shuffle.each",
	"describe.skipIf.todo.each",
	"describe.skipIf.skip.for",
	"describe.skipIf.only.for",
	"describe.skipIf.concurrent.for",
	"describe.skipIf.sequential.for",
	"describe.skipIf.shuffle.for",
	"describe.skipIf.todo.for",
	"describe.runIf.skip.each",
	"describe.runIf.only.each",
	"describe.runIf.concurrent.each",
	"describe.runIf.sequential.each",
	"describe.runIf.shuffle.each",
	"describe.runIf.todo.each",
	"describe.runIf.skip.for",
	"describe.runIf.only.for",
	"describe.runIf.concurrent.for",
	"describe.runIf.sequential.for",
	"describe.runIf.shuffle.for",
	"describe.runIf.todo.for",
	"suite",
	"suite.skip",
	"suite.only",
	"suite.concurrent",
	"suite.sequential",
	"suite.shuffle",
	"suite.todo",
	"suite.skipIf",
	"suite.runIf",
	"suite.each",
	"suite.for",
	"suite.skip.only",
	"suite.skip.concurrent",
	"suite.skip.sequential",
	"suite.skip.shuffle",
	"suite.skip.todo",
	"suite.only.skip",
	"suite.only.concurrent",
	"suite.only.sequential",
	"suite.only.shuffle",
	"suite.only.todo",
	"suite.concurrent.skip",
	"suite.concurrent.only",
	"suite.concurrent.sequential",
	"suite.concurrent.shuffle",
	"suite.concurrent.todo",
	"suite.sequential.skip",
	"suite.sequential.only",
	"suite.sequential.concurrent",
	"suite.sequential.shuffle",
	"suite.sequential.todo",
	"suite.shuffle.skip",
	"suite.shuffle.only",
	"suite.shuffle.concurrent",
	"suite.shuffle.sequential",
	"suite.shuffle.todo",
	"suite.todo.skip",
	"suite.todo.only",
	"suite.todo.concurrent",
	"suite.todo.sequential",
	"suite.todo.shuffle",
	"suite.skipIf.skip",
	"suite.skipIf.only",
	"suite.skipIf.concurrent",
	"suite.skipIf.sequential",
	"suite.skipIf.shuffle",
	"suite.skipIf.todo",
	"suite.runIf.skip",
	"suite.runIf.only",
	"suite.runIf.concurrent",
	"suite.runIf.sequential",
	"suite.runIf.shuffle",
	"suite.runIf.todo",
	"suite.skip.each",
	"suite.only.each",
	"suite.concurrent.each",
	"suite.sequential.each",
	"suite.shuffle.each",
	"suite.todo.each",
	"suite.skip.for",
	"suite.only.for",
	"suite.concurrent.for",
	"suite.sequential.for",
	"suite.shuffle.for",
	"suite.todo.for",
	"suite.skipIf.each",
	"suite.skipIf.for",
	"suite.runIf.each",
	"suite.runIf.for",
	"suite.skip.only.concurrent",
	"suite.skip.only.sequential",
	"suite.skip.only.shuffle",
	"suite.skip.only.todo",
	"suite.skip.concurrent.only",
	"suite.skip.concurrent.sequential",
	"suite.skip.concurrent.shuffle",
	"suite.skip.concurrent.todo",
	"suite.skip.sequential.only",
	"suite.skip.sequential.concurrent",
	"suite.skip.sequential.shuffle",
	"suite.skip.sequential.todo",
	"suite.skip.shuffle.only",
	"suite.skip.shuffle.concurrent",
	"suite.skip.shuffle.sequential",
	"suite.skip.shuffle.todo",
	"suite.skip.todo.only",
	"suite.skip.todo.concurrent",
	"suite.skip.todo.sequential",
	"suite.skip.todo.shuffle",
	"suite.only.skip.concurrent",
	"suite.only.skip.sequential",
	"suite.only.skip.shuffle",
	"suite.only.skip.todo",
	"suite.only.concurrent.skip",
	"suite.only.concurrent.sequential",
	"suite.only.concurrent.shuffle",
	"suite.only.concurrent.todo",
	"suite.only.sequential.skip",
	"suite.only.sequential.concurrent",
	"suite.only.sequential.shuffle",
	"suite.only.sequential.todo",
	"suite.only.shuffle.skip",
	"suite.only.shuffle.concurrent",
	"suite.only.shuffle.sequential",
	"suite.only.shuffle.todo",
	"suite.only.todo.skip",
	"suite.only.todo.concurrent",
	"suite.only.todo.sequential",
	"suite.only.todo.shuffle",
	"suite.concurrent.skip.only",
	"suite.concurrent.skip.sequential",
	"suite.concurrent.skip.shuffle",
	"suite.concurrent.skip.todo",
	"suite.concurrent.only.skip",
	"suite.concurrent.only.sequential",
	"suite.concurrent.only.shuffle",
	"suite.concurrent.only.todo",
	"suite.concurrent.sequential.skip",
	"suite.concurrent.sequential.only",
	"suite.concurrent.sequential.shuffle",
	"suite.concurrent.sequential.todo",
	"suite.concurrent.shuffle.skip",
	"suite.concurrent.shuffle.only",
	"suite.concurrent.shuffle.sequential",
	"suite.concurrent.shuffle.todo",
	"suite.concurrent.todo.skip",
	"suite.concurrent.todo.only",
	"suite.concurrent.todo.sequential",
	"suite.concurrent.todo.shuffle",
	"suite.sequential.skip.only",
	"suite.sequential.skip.concurrent",
	"suite.sequential.skip.shuffle",
	"suite.sequential.skip.todo",
	"suite.sequential.only.skip",
	"suite.sequential.only.concurrent",
	"suite.sequential.only.shuffle",
	"suite.sequential.only.todo",
	"suite.sequential.concurrent.skip",
	"suite.sequential.concurrent.only",
	"suite.sequential.concurrent.shuffle",
	"suite.sequential.concurrent.todo",
	"suite.sequential.shuffle.skip",
	"suite.sequential.shuffle.only",
	"suite.sequential.shuffle.concurrent",
	"suite.sequential.shuffle.todo",
	"suite.sequential.todo.skip",
	"suite.sequential.todo.only",
	"suite.sequential.todo.concurrent",
	"suite.sequential.todo.shuffle",
	"suite.shuffle.skip.only",
	"suite.shuffle.skip.concurrent",
	"suite.shuffle.skip.sequential",
	"suite.shuffle.skip.todo",
	"suite.shuffle.only.skip",
	"suite.shuffle.only.concurrent",
	"suite.shuffle.only.sequential",
	"suite.shuffle.only.todo",
	"suite.shuffle.concurrent.skip",
	"suite.shuffle.concurrent.only",
	"suite.shuffle.concurrent.sequential",
	"suite.shuffle.concurrent.todo",
	"suite.shuffle.sequential.skip",
	"suite.shuffle.sequential.only",
	"suite.shuffle.sequential.concurrent",
	"suite.shuffle.sequential.todo",
	"suite.shuffle.todo.skip",
	"suite.shuffle.todo.only",
	"suite.shuffle.todo.concurrent",
	"suite.shuffle.todo.sequential",
	"suite.todo.skip.only",
	"suite.todo.skip.concurrent",
	"suite.todo.skip.sequential",
	"suite.todo.skip.shuffle",
	"suite.todo.only.skip",
	"suite.todo.only.concurrent",
	"suite.todo.only.sequential",
	"suite.todo.only.shuffle",
	"suite.todo.concurrent.skip",
	"suite.todo.concurrent.only",
	"suite.todo.concurrent.sequential",
	"suite.todo.concurrent.shuffle",
	"suite.todo.sequential.skip",
	"suite.todo.sequential.only",
	"suite.todo.sequential.concurrent",
	"suite.todo.sequential.shuffle",
	"suite.todo.shuffle.skip",
	"suite.todo.shuffle.only",
	"suite.todo.shuffle.concurrent",
	"suite.todo.shuffle.sequential",
	"suite.skipIf.skip.only",
	"suite.skipIf.skip.concurrent",
	"suite.skipIf.skip.sequential",
	"suite.skipIf.skip.shuffle",
	"suite.skipIf.skip.todo",
	"suite.skipIf.only.skip",
	"suite.skipIf.only.concurrent",
	"suite.skipIf.only.sequential",
	"suite.skipIf.only.shuffle",
	"suite.skipIf.only.todo",
	"suite.skipIf.concurrent.skip",
	"suite.skipIf.concurrent.only",
	"suite.skipIf.concurrent.sequential",
	"suite.skipIf.concurrent.shuffle",
	"suite.skipIf.concurrent.todo",
	"suite.skipIf.sequential.skip",
	"suite.skipIf.sequential.only",
	"suite.skipIf.sequential.concurrent",
	"suite.skipIf.sequential.shuffle",
	"suite.skipIf.sequential.todo",
	"suite.skipIf.shuffle.skip",
	"suite.skipIf.shuffle.only",
	"suite.skipIf.shuffle.concurrent",
	"suite.skipIf.shuffle.sequential",
	"suite.skipIf.shuffle.todo",
	"suite.skipIf.todo.skip",
	"suite.skipIf.todo.only",
	"suite.skipIf.todo.concurrent",
	"suite.skipIf.todo.sequential",
	"suite.skipIf.todo.shuffle",
	"suite.runIf.skip.only",
	"suite.runIf.skip.concurrent",
	"suite.runIf.skip.sequential",
	"suite.runIf.skip.shuffle",
	"suite.runIf.skip.todo",
	"suite.runIf.only.skip",
	"suite.runIf.only.concurrent",
	"suite.runIf.only.sequential",
	"suite.runIf.only.shuffle",
	"suite.runIf.only.todo",
	"suite.runIf.concurrent.skip",
	"suite.runIf.concurrent.only",
	"suite.runIf.concurrent.sequential",
	"suite.runIf.concurrent.shuffle",
	"suite.runIf.concurrent.todo",
	"suite.runIf.sequential.skip",
	"suite.runIf.sequential.only",
	"suite.runIf.sequential.concurrent",
	"suite.runIf.sequential.shuffle",
	"suite.runIf.sequential.todo",
	"suite.runIf.shuffle.skip",
	"suite.runIf.shuffle.only",
	"suite.runIf.shuffle.concurrent",
	"suite.runIf.shuffle.sequential",
	"suite.runIf.shuffle.todo",
	"suite.runIf.todo.skip",
	"suite.runIf.todo.only",
	"suite.runIf.todo.concurrent",
	"suite.runIf.todo.sequential",
	"suite.runIf.todo.shuffle",
	"suite.skip.only.each",
	"suite.skip.concurrent.each",
	"suite.skip.sequential.each",
	"suite.skip.shuffle.each",
	"suite.skip.todo.each",
	"suite.only.skip.each",
	"suite.only.concurrent.each",
	"suite.only.sequential.each",
	"suite.only.shuffle.each",
	"suite.only.todo.each",
	"suite.concurrent.skip.each",
	"suite.concurrent.only.each",
	"suite.concurrent.sequential.each",
	"suite.concurrent.shuffle.each",
	"suite.concurrent.todo.each",
	"suite.sequential.skip.each",
	"suite.sequential.only.each",
	"suite.sequential.concurrent.each",
	"suite.sequential.shuffle.each",
	"suite.sequential.todo.each",
	"suite.shuffle.skip.each",
	"suite.shuffle.only.each",
	"suite.shuffle.concurrent.each",
	"suite.shuffle.sequential.each",
	"suite.shuffle.todo.each",
	"suite.todo.skip.each",
	"suite.todo.only.each",
	"suite.todo.concurrent.each",
	"suite.todo.sequential.each",
	"suite.todo.shuffle.each",
	"suite.skip.only.for",
	"suite.skip.concurrent.for",
	"suite.skip.sequential.for",
	"suite.skip.shuffle.for",
	"suite.skip.todo.for",
	"suite.only.skip.for",
	"suite.only.concurrent.for",
	"suite.only.sequential.for",
	"suite.only.shuffle.for",
	"suite.only.todo.for",
	"suite.concurrent.skip.for",
	"suite.concurrent.only.for",
	"suite.concurrent.sequential.for",
	"suite.concurrent.shuffle.for",
	"suite.concurrent.todo.for",
	"suite.sequential.skip.for",
	"suite.sequential.only.for",
	"suite.sequential.concurrent.for",
	"suite.sequential.shuffle.for",
	"suite.sequential.todo.for",
	"suite.shuffle.skip.for",
	"suite.shuffle.only.for",
	"suite.shuffle.concurrent.for",
	"suite.shuffle.sequential.for",
	"suite.shuffle.todo.for",
	"suite.todo.skip.for",
	"suite.todo.only.for",
	"suite.todo.concurrent.for",
	"suite.todo.sequential.for",
	"suite.todo.shuffle.for",
	"suite.skipIf.skip.each",
	"suite.skipIf.only.each",
	"suite.skipIf.concurrent.each",
	"suite.skipIf.sequential.each",
	"suite.skipIf.shuffle.each",
	"suite.skipIf.todo.each",
	"suite.skipIf.skip.for",
	"suite.skipIf.only.for",
	"suite.skipIf.concurrent.for",
	"suite.skipIf.sequential.for",
	"suite.skipIf.shuffle.for",
	"suite.skipIf.todo.for",
	"suite.runIf.skip.each",
	"suite.runIf.only.each",
	"suite.runIf.concurrent.each",
	"suite.runIf.sequential.each",
	"suite.runIf.shuffle.each",
	"suite.runIf.todo.each",
	"suite.runIf.skip.for",
	"suite.runIf.only.for",
	"suite.runIf.concurrent.for",
	"suite.runIf.sequential.for",
	"suite.runIf.shuffle.for",
	"suite.runIf.todo.for",
	"xtest",
	"xtest.each",
	"xit",
	"xit.each",
	"fit",
	"xdescribe",
	"xdescribe.each",
	"fdescribe"
]);

//#endregion
//#region src/utils/scope.ts
function getScope(context, node) {
	return context.sourceCode.getScope ? context.sourceCode.getScope(node) : context.getScope();
}
function getModuleScope(context, node) {
	let scope = getScope(context, node);
	while (scope) {
		if (scope.type === "module") return scope;
		scope = scope.upper;
	}
	return scope;
}

//#endregion
//#region src/utils/parse-vitest-fn-call.ts
const isTypeOfVitestFnCall = (node, context, types) => {
	const vitestFnCall = parseVitestFnCall(node, context);
	return vitestFnCall !== null && types.includes(vitestFnCall.type);
};
const parseVitestFnCall = (node, context) => {
	const vitestFnCall = parseVitestFnCallWithReason(node, context);
	if (typeof vitestFnCall === "string") return null;
	return vitestFnCall;
};
const parseVitestFnCallCache = /* @__PURE__ */ new WeakMap();
const parseVitestFnCallWithReason = (node, context) => {
	let parsedVitestFnCall = parseVitestFnCallCache.get(node);
	if (parsedVitestFnCall) return parsedVitestFnCall;
	parsedVitestFnCall = parseVitestFnCallWithReasonInner(node, context);
	parseVitestFnCallCache.set(node, parsedVitestFnCall);
	return parsedVitestFnCall;
};
const determineVitestFnType = (name) => {
	if (name === "expect") return "expect";
	if (name === "expectTypeOf") return "expectTypeOf";
	if (name === "vi" || name === "vitest") return "vi";
	if (Object.prototype.hasOwnProperty.call(DescribeAlias, name)) return "describe";
	if (Object.prototype.hasOwnProperty.call(TestCaseName, name)) return "test";
	if (Object.prototype.hasOwnProperty.call(HookName, name)) return "hook";
	return "unknown";
};
const findModifiersAndMatcher = (members) => {
	const modifiers = [];
	for (const member of members) {
		if (member.parent?.type === AST_NODE_TYPES.MemberExpression && member.parent.parent?.type === AST_NODE_TYPES.CallExpression) return {
			matcher: member,
			args: member.parent.parent.arguments,
			modifiers
		};
		const name = getAccessorValue(member);
		if (modifiers.length === 0) {
			if (!Object.prototype.hasOwnProperty.call(ModifierName, name)) return "modifier-unknown";
		} else if (modifiers.length === 1) {
			if (name !== ModifierName.not && name != ModifierName.have) return "modifier-unknown";
			const firstModifier = getAccessorValue(modifiers[0]);
			if (firstModifier !== ModifierName.resolves && firstModifier !== ModifierName.rejects && firstModifier !== ModifierName.to) return "modifier-unknown";
		} else return "modifier-unknown";
		modifiers.push(member);
	}
	return "matcher-not-found";
};
const parseVitestExpectCall = (typelessParsedVitestFnCall, type) => {
	const modifiersMatcher = findModifiersAndMatcher(typelessParsedVitestFnCall.members);
	if (typeof modifiersMatcher === "string") return modifiersMatcher;
	return {
		...typelessParsedVitestFnCall,
		type,
		...modifiersMatcher
	};
};
const findTopMostCallExpression = (node) => {
	let topMostCallExpression = node;
	let { parent } = node;
	while (parent) {
		if (parent.type === AST_NODE_TYPES.CallExpression) {
			topMostCallExpression = parent;
			parent = parent.parent;
			continue;
		}
		if (parent.type !== AST_NODE_TYPES.MemberExpression) break;
		parent = parent.parent;
	}
	return topMostCallExpression;
};
const parseVitestFnCallWithReasonInner = (node, context) => {
	const chain = getNodeChain(node);
	if (!chain?.length) return null;
	const [first, ...rest] = chain;
	const lastLink = getAccessorValue(chain[chain.length - 1]);
	if (lastLink === "each") {
		if (node.callee.type !== AST_NODE_TYPES.CallExpression && node.callee.type !== AST_NODE_TYPES.TaggedTemplateExpression) return null;
	}
	if (node.callee.type === AST_NODE_TYPES.TaggedTemplateExpression && lastLink !== "each") return null;
	const resolved = resolveVitestFn(context, node, getAccessorValue(first));
	if (!resolved) return null;
	const name = resolved.original ?? resolved.local;
	const links = [name, ...rest.map(getAccessorValue)];
	if (resolved.type !== "testContext" && name !== "vi" && name !== "vitest" && name !== "expect" && name !== "expectTypeOf" && !ValidVitestFnCallChains.has(links.join("."))) return null;
	const parsedVitestFnCall = {
		name,
		head: {