diff --git a/crates/oxc_linter/src/rules/jest/require_hook.rs b/crates/oxc_linter/src/rules/jest/require_hook.rs
index 058e223783555..e2f907a43f497 100644
--- a/crates/oxc_linter/src/rules/jest/require_hook.rs
+++ b/crates/oxc_linter/src/rules/jest/require_hook.rs
@@ -9,7 +9,6 @@ use oxc_semantic::AstNode;
 use oxc_span::{CompactStr, Span};
 use schemars::JsonSchema;
 use serde::Deserialize;
-use std::borrow::Cow;
 
 use crate::{
     context::LintContext,
@@ -256,7 +255,7 @@ impl RequireHook {
                 return;
             };
 
-            if !(is_valid_vitest_call(&[Cow::Borrowed(fn_type)])
+            if !(is_valid_vitest_call(&[fn_type])
                 || name.starts_with("jest.")
                 || name.starts_with("vi.")
                 || self.allowed_function_calls.contains(&name))
diff --git a/crates/oxc_linter/src/utils/vitest/valid_vitest_fn.rs b/crates/oxc_linter/src/utils/vitest/valid_vitest_fn.rs
index eb01484a2495c..332e82206d00a 100644
--- a/crates/oxc_linter/src/utils/vitest/valid_vitest_fn.rs
+++ b/crates/oxc_linter/src/utils/vitest/valid_vitest_fn.rs
@@ -1,1305 +1,184 @@
-use std::borrow::Cow;
+/// Returns true if the given array of strings represents a valid Vitest function call
+/// with optional modifiers, such as `test.todo.only`.
+pub fn is_valid_vitest_call<T: AsRef<str>>(members: &[T]) -> bool {
+    match members[0].as_ref() {
+        "afterAll" | "afterEach" | "beforeAll" | "beforeEach" => members.len() == 1,
+        "bench" => is_valid_bench_chain(&members[1..]),
+        "describe" | "suite" => is_valid_describe_chain(&members[1..]),
+        "it" | "test" => is_valid_it_chain(&members[1..]),
+        _ => false,
+    }
+}
+
+/// Check for duplicate modifiers. This has quadratic complexity, but since we only
+/// have a very small number of modifiers, this is fine.
+fn has_duplicates<T: AsRef<str>>(modifiers: &[T]) -> bool {
+    let len = modifiers.len();
+    for i in 0..len {
+        for j in (i + 1)..len {
+            if modifiers[i].as_ref() == modifiers[j].as_ref() {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn is_valid_bench_chain<T: AsRef<str>>(modifiers: &[T]) -> bool {
+    for modifier in modifiers {
+        if !matches!(modifier.as_ref(), "only" | "runIf" | "skip" | "skipIf" | "todo") {
+            return false;
+        }
+    }
+
+    !has_duplicates(modifiers)
+}
+
+fn is_valid_describe_chain<T: AsRef<str>>(modifiers: &[T]) -> bool {
+    for (i, modifier) in modifiers.iter().enumerate() {
+        match modifier.as_ref() {
+            "each" | "for" => {
+                // each must be at the end
+                if i != modifiers.len() - 1 {
+                    return false;
+                }
+            }
+            "concurrent" | "only" | "runIf" | "sequential" | "shuffle" | "skip" | "skipIf"
+            | "todo" => {}
+            _ => return false,
+        }
+    }
+
+    !has_duplicates(modifiers)
+}
+
+fn is_valid_it_chain<T: AsRef<str>>(modifiers: &[T]) -> bool {
+    for (i, modifier) in modifiers.iter().enumerate() {
+        match modifier.as_ref() {
+            "each" => {
+                // each must be at the end
+                if i != modifiers.len() - 1 {
+                    return false;
+                }
+            }
+            "extend" => {
+                // extend must be at the beginning (first modifier after it/test)
+                if i != 0 {
+                    return false;
+                }
+            }
+            "concurrent" | "fails" | "only" | "runIf" | "sequential" | "skip" | "skipIf"
+            | "todo" => {}
+            _ => return false,
+        }
+    }
+
+    !has_duplicates(modifiers)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_simple_base_functions() {
+        assert!(is_valid_vitest_call(&["afterAll"]));
+        assert!(is_valid_vitest_call(&["afterEach"]));
+        assert!(is_valid_vitest_call(&["beforeAll"]));
+        assert!(is_valid_vitest_call(&["beforeEach"]));
+        assert!(!is_valid_vitest_call(&["fdescribe"]));
+        assert!(!is_valid_vitest_call(&["fit"]));
+
+        // These should not accept modifiers
+        assert!(!is_valid_vitest_call(&["afterAll", "only"]));
+        assert!(!is_valid_vitest_call(&["beforeEach", "skip"]));
+    }
+
+    // These are not supported in Vitest, as far as I can tell.
+    #[test]
+    fn test_x_functions() {
+        assert!(!is_valid_vitest_call(&["xdescribe"]));
+        assert!(!is_valid_vitest_call(&["xdescribe", "each"]));
+        assert!(!is_valid_vitest_call(&["xit"]));
+        assert!(!is_valid_vitest_call(&["xit", "each"]));
+        assert!(!is_valid_vitest_call(&["xtest"]));
+        assert!(!is_valid_vitest_call(&["xtest", "each"]));
+        assert!(!is_valid_vitest_call(&["xdescribe", "only"]));
+        assert!(!is_valid_vitest_call(&["xit", "skip"]));
+    }
+
+    #[test]
+    fn test_bench() {
+        assert!(is_valid_vitest_call(&["bench"]));
+        assert!(is_valid_vitest_call(&["bench", "only"]));
+        assert!(is_valid_vitest_call(&["bench", "skip"]));
+        assert!(is_valid_vitest_call(&["bench", "todo"]));
+        assert!(is_valid_vitest_call(&["bench", "runIf"]));
+        assert!(is_valid_vitest_call(&["bench", "skipIf"]));
+        assert!(is_valid_vitest_call(&["bench", "only", "skip"]));
+        assert!(is_valid_vitest_call(&["bench", "only", "skip", "todo"]));
+
+        // Invalid: concurrent is not a bench modifier
+        assert!(!is_valid_vitest_call(&["bench", "concurrent"]));
+        // Invalid: duplicates
+        assert!(!is_valid_vitest_call(&["bench", "only", "only"]));
+    }
+
+    #[test]
+    fn test_describe_and_suite() {
+        assert!(is_valid_vitest_call(&["describe"]));
+        assert!(is_valid_vitest_call(&["suite"]));
+        assert!(is_valid_vitest_call(&["describe", "concurrent"]));
+        assert!(is_valid_vitest_call(&["describe", "each"]));
+        assert!(is_valid_vitest_call(&["describe", "only"]));
+        assert!(is_valid_vitest_call(&["describe", "for"]));
+        assert!(is_valid_vitest_call(&["describe", "concurrent", "each"]));
+        assert!(is_valid_vitest_call(&["describe", "only", "concurrent", "each"]));
+
+        // each must be at the end
+        assert!(!is_valid_vitest_call(&["describe", "each", "only"]));
+
+        // Invalid: fails is not a describe modifier
+        assert!(!is_valid_vitest_call(&["describe", "fails"]));
+        // Invalid: duplicates
+        assert!(!is_valid_vitest_call(&["describe", "only", "only"]));
+    }
+
+    #[test]
+    fn test_it_and_test() {
+        assert!(is_valid_vitest_call(&["it"]));
+        assert!(is_valid_vitest_call(&["test"]));
+        assert!(is_valid_vitest_call(&["it", "concurrent"]));
+        assert!(is_valid_vitest_call(&["it", "each"]));
+        assert!(is_valid_vitest_call(&["it", "extend"]));
+        assert!(is_valid_vitest_call(&["it", "fails"]));
+        assert!(is_valid_vitest_call(&["it", "only"]));
+        assert!(is_valid_vitest_call(&["it", "extend", "concurrent"]));
+        assert!(is_valid_vitest_call(&["it", "extend", "fails", "each"]));
 
-static VALID_VITEST_FN_CALL_CHAINS: phf::Set<&'static str> = phf::phf_set![
-    "afterAll",
-    "afterEach",
-    "beforeAll",
-    "beforeEach",
-    "bench",
-    "bench.only",
-    "bench.only.skip",
-    "bench.only.skip.todo",
-    "bench.only.todo",
-    "bench.only.todo.skip",
-    "bench.runIf",
-    "bench.runIf.only",
-    "bench.runIf.only.skip",
-    "bench.runIf.only.todo",
-    "bench.runIf.skip",
-    "bench.runIf.skip.only",
-    "bench.runIf.skip.todo",
-    "bench.runIf.todo",
-    "bench.runIf.todo.only",
-    "bench.runIf.todo.skip",
-    "bench.skip",
-    "bench.skip.only",
-    "bench.skip.only.todo",
-    "bench.skip.todo",
-    "bench.skip.todo.only",
-    "bench.skipIf",
-    "bench.skipIf.only",
-    "bench.skipIf.only.skip",
-    "bench.skipIf.only.todo",
-    "bench.skipIf.skip",
-    "bench.skipIf.skip.only",
-    "bench.skipIf.skip.todo",
-    "bench.skipIf.todo",
-    "bench.skipIf.todo.only",
-    "bench.skipIf.todo.skip",
-    "bench.todo",
-    "bench.todo.only",
-    "bench.todo.only.skip",
-    "bench.todo.skip",
-    "bench.todo.skip.only",
-    "describe",
-    "describe.concurrent",
-    "describe.concurrent.each",
-    "describe.concurrent.only",
-    "describe.concurrent.only.each",
-    "describe.concurrent.only.sequential",
-    "describe.concurrent.only.shuffle",
-    "describe.concurrent.only.skip",
-    "describe.concurrent.only.todo",
-    "describe.concurrent.sequential",
-    "describe.concurrent.sequential.each",
-    "describe.concurrent.sequential.only",
-    "describe.concurrent.sequential.shuffle",
-    "describe.concurrent.sequential.skip",
-    "describe.concurrent.sequential.todo",
-    "describe.concurrent.shuffle",
-    "describe.concurrent.shuffle.each",
-    "describe.concurrent.shuffle.only",
-    "describe.concurrent.shuffle.sequential",
-    "describe.concurrent.shuffle.skip",
-    "describe.concurrent.shuffle.todo",
-    "describe.concurrent.skip",
-    "describe.concurrent.skip.each",
-    "describe.concurrent.skip.only",
-    "describe.concurrent.skip.sequential",
-    "describe.concurrent.skip.shuffle",
-    "describe.concurrent.skip.todo",
-    "describe.concurrent.todo",
-    "describe.concurrent.todo.each",
-    "describe.concurrent.todo.only",
-    "describe.concurrent.todo.sequential",
-    "describe.concurrent.todo.shuffle",
-    "describe.concurrent.todo.skip",
-    "describe.each",
-    "describe.for",
-    "describe.only",
-    "describe.only.concurrent",
-    "describe.only.concurrent.each",
-    "describe.only.concurrent.sequential",
-    "describe.only.concurrent.shuffle",
-    "describe.only.concurrent.skip",
-    "describe.only.concurrent.todo",
-    "describe.only.each",
-    "describe.only.sequential",
-    "describe.only.sequential.concurrent",
-    "describe.only.sequential.each",
-    "describe.only.sequential.shuffle",
-    "describe.only.sequential.skip",
-    "describe.only.sequential.todo",
-    "describe.only.shuffle",
-    "describe.only.shuffle.concurrent",
-    "describe.only.shuffle.each",
-    "describe.only.shuffle.sequential",
-    "describe.only.shuffle.skip",
-    "describe.only.shuffle.todo",
-    "describe.only.skip",
-    "describe.only.skip.concurrent",
-    "describe.only.skip.each",
-    "describe.only.skip.sequential",
-    "describe.only.skip.shuffle",
-    "describe.only.skip.todo",
-    "describe.only.todo",
-    "describe.only.todo.concurrent",
-    "describe.only.todo.each",
-    "describe.only.todo.sequential",
-    "describe.only.todo.shuffle",
-    "describe.only.todo.skip",
-    "describe.runIf",
-    "describe.runIf.concurrent",
-    "describe.runIf.concurrent.each",
-    "describe.runIf.concurrent.only",
-    "describe.runIf.concurrent.sequential",
-    "describe.runIf.concurrent.shuffle",
-    "describe.runIf.concurrent.skip",
-    "describe.runIf.concurrent.todo",
-    "describe.runIf.each",
-    "describe.runIf.only",
-    "describe.runIf.only.concurrent",
-    "describe.runIf.only.each",
-    "describe.runIf.only.sequential",
-    "describe.runIf.only.shuffle",
-    "describe.runIf.only.skip",
-    "describe.runIf.only.todo",
-    "describe.runIf.sequential",
-    "describe.runIf.sequential.concurrent",
-    "describe.runIf.sequential.each",
-    "describe.runIf.sequential.only",
-    "describe.runIf.sequential.shuffle",
-    "describe.runIf.sequential.skip",
-    "describe.runIf.sequential.todo",
-    "describe.runIf.shuffle",
-    "describe.runIf.shuffle.concurrent",
-    "describe.runIf.shuffle.each",
-    "describe.runIf.shuffle.only",
-    "describe.runIf.shuffle.sequential",
-    "describe.runIf.shuffle.skip",
-    "describe.runIf.shuffle.todo",
-    "describe.runIf.skip",
-    "describe.runIf.skip.concurrent",
-    "describe.runIf.skip.each",
-    "describe.runIf.skip.only",
-    "describe.runIf.skip.sequential",
-    "describe.runIf.skip.shuffle",
-    "describe.runIf.skip.todo",
-    "describe.runIf.todo",
-    "describe.runIf.todo.concurrent",
-    "describe.runIf.todo.each",
-    "describe.runIf.todo.only",
-    "describe.runIf.todo.sequential",
-    "describe.runIf.todo.shuffle",
-    "describe.runIf.todo.skip",
-    "describe.sequential",
-    "describe.sequential.concurrent",
-    "describe.sequential.concurrent.each",
-    "describe.sequential.concurrent.only",
-    "describe.sequential.concurrent.shuffle",
-    "describe.sequential.concurrent.skip",
-    "describe.sequential.concurrent.todo",
-    "describe.sequential.each",
-    "describe.sequential.only",
-    "describe.sequential.only.concurrent",
-    "describe.sequential.only.each",
-    "describe.sequential.only.shuffle",
-    "describe.sequential.only.skip",
-    "describe.sequential.only.todo",
-    "describe.sequential.shuffle",
-    "describe.sequential.shuffle.concurrent",
-    "describe.sequential.shuffle.each",
-    "describe.sequential.shuffle.only",
-    "describe.sequential.shuffle.skip",
-    "describe.sequential.shuffle.todo",
-    "describe.sequential.skip",
-    "describe.sequential.skip.concurrent",
-    "describe.sequential.skip.each",
-    "describe.sequential.skip.only",
-    "describe.sequential.skip.shuffle",
-    "describe.sequential.skip.todo",
-    "describe.sequential.todo",
-    "describe.sequential.todo.concurrent",
-    "describe.sequential.todo.each",
-    "describe.sequential.todo.only",
-    "describe.sequential.todo.shuffle",
-    "describe.sequential.todo.skip",
-    "describe.shuffle",
-    "describe.shuffle.concurrent",
-    "describe.shuffle.concurrent.each",
-    "describe.shuffle.concurrent.only",
-    "describe.shuffle.concurrent.sequential",
-    "describe.shuffle.concurrent.skip",
-    "describe.shuffle.concurrent.todo",
-    "describe.shuffle.each",
-    "describe.shuffle.only",
-    "describe.shuffle.only.concurrent",
-    "describe.shuffle.only.each",
-    "describe.shuffle.only.sequential",
-    "describe.shuffle.only.skip",
-    "describe.shuffle.only.todo",
-    "describe.shuffle.sequential",
-    "describe.shuffle.sequential.concurrent",
-    "describe.shuffle.sequential.each",
-    "describe.shuffle.sequential.only",
-    "describe.shuffle.sequential.skip",
-    "describe.shuffle.sequential.todo",
-    "describe.shuffle.skip",
-    "describe.shuffle.skip.concurrent",
-    "describe.shuffle.skip.each",
-    "describe.shuffle.skip.only",
-    "describe.shuffle.skip.sequential",
-    "describe.shuffle.skip.todo",
-    "describe.shuffle.todo",
-    "describe.shuffle.todo.concurrent",
-    "describe.shuffle.todo.each",
-    "describe.shuffle.todo.only",
-    "describe.shuffle.todo.sequential",
-    "describe.shuffle.todo.skip",
-    "describe.skip",
-    "describe.skip.concurrent",
-    "describe.skip.concurrent.each",
-    "describe.skip.concurrent.only",
-    "describe.skip.concurrent.sequential",
-    "describe.skip.concurrent.shuffle",
-    "describe.skip.concurrent.todo",
-    "describe.skip.each",
-    "describe.skip.only",
-    "describe.skip.only.concurrent",
-    "describe.skip.only.each",
-    "describe.skip.only.sequential",
-    "describe.skip.only.shuffle",
-    "describe.skip.only.todo",
-    "describe.skip.sequential",
-    "describe.skip.sequential.concurrent",
-    "describe.skip.sequential.each",
-    "describe.skip.sequential.only",
-    "describe.skip.sequential.shuffle",
-    "describe.skip.sequential.todo",
-    "describe.skip.shuffle",
-    "describe.skip.shuffle.concurrent",
-    "describe.skip.shuffle.each",
-    "describe.skip.shuffle.only",
-    "describe.skip.shuffle.sequential",
-    "describe.skip.shuffle.todo",
-    "describe.skip.todo",
-    "describe.skip.todo.concurrent",
-    "describe.skip.todo.each",
-    "describe.skip.todo.only",
-    "describe.skip.todo.sequential",
-    "describe.skip.todo.shuffle",
-    "describe.skipIf",
-    "describe.skipIf.concurrent",
-    "describe.skipIf.concurrent.each",
-    "describe.skipIf.concurrent.only",
-    "describe.skipIf.concurrent.sequential",
-    "describe.skipIf.concurrent.shuffle",
-    "describe.skipIf.concurrent.skip",
-    "describe.skipIf.concurrent.todo",
-    "describe.skipIf.each",
-    "describe.skipIf.only",
-    "describe.skipIf.only.concurrent",
-    "describe.skipIf.only.each",
-    "describe.skipIf.only.sequential",
-    "describe.skipIf.only.shuffle",
-    "describe.skipIf.only.skip",
-    "describe.skipIf.only.todo",
-    "describe.skipIf.sequential",
-    "describe.skipIf.sequential.concurrent",
-    "describe.skipIf.sequential.each",
-    "describe.skipIf.sequential.only",
-    "describe.skipIf.sequential.shuffle",
-    "describe.skipIf.sequential.skip",
-    "describe.skipIf.sequential.todo",
-    "describe.skipIf.shuffle",
-    "describe.skipIf.shuffle.concurrent",
-    "describe.skipIf.shuffle.each",
-    "describe.skipIf.shuffle.only",
-    "describe.skipIf.shuffle.sequential",
-    "describe.skipIf.shuffle.skip",
-    "describe.skipIf.shuffle.todo",
-    "describe.skipIf.skip",
-    "describe.skipIf.skip.concurrent",
-    "describe.skipIf.skip.each",
-    "describe.skipIf.skip.only",
-    "describe.skipIf.skip.sequential",
-    "describe.skipIf.skip.shuffle",
-    "describe.skipIf.skip.todo",
-    "describe.skipIf.todo",
-    "describe.skipIf.todo.concurrent",
-    "describe.skipIf.todo.each",
-    "describe.skipIf.todo.only",
-    "describe.skipIf.todo.sequential",
-    "describe.skipIf.todo.shuffle",
-    "describe.skipIf.todo.skip",
-    "describe.todo",
-    "describe.todo.concurrent",
-    "describe.todo.concurrent.each",
-    "describe.todo.concurrent.only",
-    "describe.todo.concurrent.sequential",
-    "describe.todo.concurrent.shuffle",
-    "describe.todo.concurrent.skip",
-    "describe.todo.each",
-    "describe.todo.only",
-    "describe.todo.only.concurrent",
-    "describe.todo.only.each",
-    "describe.todo.only.sequential",
-    "describe.todo.only.shuffle",
-    "describe.todo.only.skip",
-    "describe.todo.sequential",
-    "describe.todo.sequential.concurrent",
-    "describe.todo.sequential.each",
-    "describe.todo.sequential.only",
-    "describe.todo.sequential.shuffle",
-    "describe.todo.sequential.skip",
-    "describe.todo.shuffle",
-    "describe.todo.shuffle.concurrent",
-    "describe.todo.shuffle.each",
-    "describe.todo.shuffle.only",
-    "describe.todo.shuffle.sequential",
-    "describe.todo.shuffle.skip",
-    "describe.todo.skip",
-    "describe.todo.skip.concurrent",
-    "describe.todo.skip.each",
-    "describe.todo.skip.only",
-    "describe.todo.skip.sequential",
-    "describe.todo.skip.shuffle",
-    "fdescribe",
-    "fit",
-    "it",
-    "it.concurrent",
-    "it.concurrent.each",
-    "it.concurrent.fails",
-    "it.concurrent.fails.each",
-    "it.concurrent.fails.only",
-    "it.concurrent.fails.sequential",
-    "it.concurrent.fails.skip",
-    "it.concurrent.fails.todo",
-    "it.concurrent.only",
-    "it.concurrent.only.each",
-    "it.concurrent.only.fails",
-    "it.concurrent.only.sequential",
-    "it.concurrent.only.skip",
-    "it.concurrent.only.todo",
-    "it.concurrent.sequential",
-    "it.concurrent.sequential.each",
-    "it.concurrent.sequential.fails",
-    "it.concurrent.sequential.only",
-    "it.concurrent.sequential.skip",
-    "it.concurrent.sequential.todo",
-    "it.concurrent.skip",
-    "it.concurrent.skip.each",
-    "it.concurrent.skip.fails",
-    "it.concurrent.skip.only",
-    "it.concurrent.skip.sequential",
-    "it.concurrent.skip.todo",
-    "it.concurrent.todo",
-    "it.concurrent.todo.each",
-    "it.concurrent.todo.fails",
-    "it.concurrent.todo.only",
-    "it.concurrent.todo.sequential",
-    "it.concurrent.todo.skip",
-    "it.each",
-    "it.extend",
-    "it.extend.concurrent",
-    "it.extend.concurrent.each",
-    "it.extend.concurrent.fails",
-    "it.extend.concurrent.only",
-    "it.extend.concurrent.sequential",
-    "it.extend.concurrent.skip",
-    "it.extend.concurrent.todo",
-    "it.extend.each",
-    "it.extend.fails",
-    "it.extend.fails.concurrent",
-    "it.extend.fails.each",
-    "it.extend.fails.only",
-    "it.extend.fails.sequential",
-    "it.extend.fails.skip",
-    "it.extend.fails.todo",
-    "it.extend.only",
-    "it.extend.only.concurrent",
-    "it.extend.only.each",
-    "it.extend.only.fails",
-    "it.extend.only.sequential",
-    "it.extend.only.skip",
-    "it.extend.only.todo",
-    "it.extend.runIf",
-    "it.extend.runIf.concurrent",
-    "it.extend.runIf.each",
-    "it.extend.runIf.fails",
-    "it.extend.runIf.only",
-    "it.extend.runIf.sequential",
-    "it.extend.runIf.skip",
-    "it.extend.runIf.todo",
-    "it.extend.sequential",
-    "it.extend.sequential.concurrent",
-    "it.extend.sequential.each",
-    "it.extend.sequential.fails",
-    "it.extend.sequential.only",
-    "it.extend.sequential.skip",
-    "it.extend.sequential.todo",
-    "it.extend.skip",
-    "it.extend.skip.concurrent",
-    "it.extend.skip.each",
-    "it.extend.skip.fails",
-    "it.extend.skip.only",
-    "it.extend.skip.sequential",
-    "it.extend.skip.todo",
-    "it.extend.skipIf",
-    "it.extend.skipIf.concurrent",
-    "it.extend.skipIf.each",
-    "it.extend.skipIf.fails",
-    "it.extend.skipIf.only",
-    "it.extend.skipIf.sequential",
-    "it.extend.skipIf.skip",
-    "it.extend.skipIf.todo",
-    "it.extend.todo",
-    "it.extend.todo.concurrent",
-    "it.extend.todo.each",
-    "it.extend.todo.fails",
-    "it.extend.todo.only",
-    "it.extend.todo.sequential",
-    "it.extend.todo.skip",
-    "it.fails",
-    "it.fails.concurrent",
-    "it.fails.concurrent.each",
-    "it.fails.concurrent.only",
-    "it.fails.concurrent.sequential",
-    "it.fails.concurrent.skip",
-    "it.fails.concurrent.todo",
-    "it.fails.each",
-    "it.fails.only",
-    "it.fails.only.concurrent",
-    "it.fails.only.each",
-    "it.fails.only.sequential",
-    "it.fails.only.skip",
-    "it.fails.only.todo",
-    "it.fails.sequential",
-    "it.fails.sequential.concurrent",
-    "it.fails.sequential.each",
-    "it.fails.sequential.only",
-    "it.fails.sequential.skip",
-    "it.fails.sequential.todo",
-    "it.fails.skip",
-    "it.fails.skip.concurrent",
-    "it.fails.skip.each",
-    "it.fails.skip.only",
-    "it.fails.skip.sequential",
-    "it.fails.skip.todo",
-    "it.fails.todo",
-    "it.fails.todo.concurrent",
-    "it.fails.todo.each",
-    "it.fails.todo.only",
-    "it.fails.todo.sequential",
-    "it.fails.todo.skip",
-    "it.only",
-    "it.only.concurrent",
-    "it.only.concurrent.each",
-    "it.only.concurrent.fails",
-    "it.only.concurrent.sequential",
-    "it.only.concurrent.skip",
-    "it.only.concurrent.todo",
-    "it.only.each",
-    "it.only.fails",
-    "it.only.fails.concurrent",
-    "it.only.fails.each",
-    "it.only.fails.sequential",
-    "it.only.fails.skip",
-    "it.only.fails.todo",
-    "it.only.sequential",
-    "it.only.sequential.concurrent",
-    "it.only.sequential.each",
-    "it.only.sequential.fails",
-    "it.only.sequential.skip",
-    "it.only.sequential.todo",
-    "it.only.skip",
-    "it.only.skip.concurrent",
-    "it.only.skip.each",
-    "it.only.skip.fails",
-    "it.only.skip.sequential",
-    "it.only.skip.todo",
-    "it.only.todo",
-    "it.only.todo.concurrent",
-    "it.only.todo.each",
-    "it.only.todo.fails",
-    "it.only.todo.sequential",
-    "it.only.todo.skip",
-    "it.runIf",
-    "it.runIf.concurrent",
-    "it.runIf.concurrent.each",
-    "it.runIf.concurrent.fails",
-    "it.runIf.concurrent.only",
-    "it.runIf.concurrent.sequential",
-    "it.runIf.concurrent.skip",
-    "it.runIf.concurrent.todo",
-    "it.runIf.each",
-    "it.runIf.fails",
-    "it.runIf.fails.concurrent",
-    "it.runIf.fails.each",
-    "it.runIf.fails.only",
-    "it.runIf.fails.sequential",
-    "it.runIf.fails.skip",
-    "it.runIf.fails.todo",
-    "it.runIf.only",
-    "it.runIf.only.concurrent",
-    "it.runIf.only.each",
-    "it.runIf.only.fails",
-    "it.runIf.only.sequential",
-    "it.runIf.only.skip",
-    "it.runIf.only.todo",
-    "it.runIf.sequential",
-    "it.runIf.sequential.concurrent",
-    "it.runIf.sequential.each",
-    "it.runIf.sequential.fails",
-    "it.runIf.sequential.only",
-    "it.runIf.sequential.skip",
-    "it.runIf.sequential.todo",
-    "it.runIf.skip",
-    "it.runIf.skip.concurrent",
-    "it.runIf.skip.each",
-    "it.runIf.skip.fails",
-    "it.runIf.skip.only",
-    "it.runIf.skip.sequential",
-    "it.runIf.skip.todo",
-    "it.runIf.todo",
-    "it.runIf.todo.concurrent",
-    "it.runIf.todo.each",
-    "it.runIf.todo.fails",
-    "it.runIf.todo.only",
-    "it.runIf.todo.sequential",
-    "it.runIf.todo.skip",
-    "it.sequential",
-    "it.sequential.concurrent",
-    "it.sequential.concurrent.each",
-    "it.sequential.concurrent.fails",
-    "it.sequential.concurrent.only",
-    "it.sequential.concurrent.skip",
-    "it.sequential.concurrent.todo",
-    "it.sequential.each",
-    "it.sequential.fails",
-    "it.sequential.fails.concurrent",
-    "it.sequential.fails.each",
-    "it.sequential.fails.only",
-    "it.sequential.fails.skip",
-    "it.sequential.fails.todo",
-    "it.sequential.only",
-    "it.sequential.only.concurrent",
-    "it.sequential.only.each",
-    "it.sequential.only.fails",
-    "it.sequential.only.skip",
-    "it.sequential.only.todo",
-    "it.sequential.skip",
-    "it.sequential.skip.concurrent",
-    "it.sequential.skip.each",
-    "it.sequential.skip.fails",
-    "it.sequential.skip.only",
-    "it.sequential.skip.todo",
-    "it.sequential.todo",
-    "it.sequential.todo.concurrent",
-    "it.sequential.todo.each",
-    "it.sequential.todo.fails",
-    "it.sequential.todo.only",
-    "it.sequential.todo.skip",
-    "it.skip",
-    "it.skip.concurrent",
-    "it.skip.concurrent.each",
-    "it.skip.concurrent.fails",
-    "it.skip.concurrent.only",
-    "it.skip.concurrent.sequential",
-    "it.skip.concurrent.todo",
-    "it.skip.each",
-    "it.skip.fails",
-    "it.skip.fails.concurrent",
-    "it.skip.fails.each",
-    "it.skip.fails.only",
-    "it.skip.fails.sequential",
-    "it.skip.fails.todo",
-    "it.skip.only",
-    "it.skip.only.concurrent",
-    "it.skip.only.each",
-    "it.skip.only.fails",
-    "it.skip.only.sequential",
-    "it.skip.only.todo",
-    "it.skip.sequential",
-    "it.skip.sequential.concurrent",
-    "it.skip.sequential.each",
-    "it.skip.sequential.fails",
-    "it.skip.sequential.only",
-    "it.skip.sequential.todo",
-    "it.skip.todo",
-    "it.skip.todo.concurrent",
-    "it.skip.todo.each",
-    "it.skip.todo.fails",
-    "it.skip.todo.only",
-    "it.skip.todo.sequential",
-    "it.skipIf",
-    "it.skipIf.concurrent",
-    "it.skipIf.concurrent.each",
-    "it.skipIf.concurrent.fails",
-    "it.skipIf.concurrent.only",
-    "it.skipIf.concurrent.sequential",
-    "it.skipIf.concurrent.skip",
-    "it.skipIf.concurrent.todo",
-    "it.skipIf.each",
-    "it.skipIf.fails",
-    "it.skipIf.fails.concurrent",
-    "it.skipIf.fails.each",
-    "it.skipIf.fails.only",
-    "it.skipIf.fails.sequential",
-    "it.skipIf.fails.skip",
-    "it.skipIf.fails.todo",
-    "it.skipIf.only",
-    "it.skipIf.only.concurrent",
-    "it.skipIf.only.each",
-    "it.skipIf.only.fails",
-    "it.skipIf.only.sequential",
-    "it.skipIf.only.skip",
-    "it.skipIf.only.todo",
-    "it.skipIf.sequential",
-    "it.skipIf.sequential.concurrent",
-    "it.skipIf.sequential.each",
-    "it.skipIf.sequential.fails",
-    "it.skipIf.sequential.only",
-    "it.skipIf.sequential.skip",
-    "it.skipIf.sequential.todo",
-    "it.skipIf.skip",
-    "it.skipIf.skip.concurrent",
-    "it.skipIf.skip.each",
-    "it.skipIf.skip.fails",
-    "it.skipIf.skip.only",
-    "it.skipIf.skip.sequential",
-    "it.skipIf.skip.todo",
-    "it.skipIf.todo",
-    "it.skipIf.todo.concurrent",
-    "it.skipIf.todo.each",
-    "it.skipIf.todo.fails",
-    "it.skipIf.todo.only",
-    "it.skipIf.todo.sequential",
-    "it.skipIf.todo.skip",
-    "it.todo",
-    "it.todo.concurrent",
-    "it.todo.concurrent.each",
-    "it.todo.concurrent.fails",
-    "it.todo.concurrent.only",
-    "it.todo.concurrent.sequential",
-    "it.todo.concurrent.skip",
-    "it.todo.each",
-    "it.todo.fails",
-    "it.todo.fails.concurrent",
-    "it.todo.fails.each",
-    "it.todo.fails.only",
-    "it.todo.fails.sequential",
-    "it.todo.fails.skip",
-    "it.todo.only",
-    "it.todo.only.concurrent",
-    "it.todo.only.each",
-    "it.todo.only.fails",
-    "it.todo.only.sequential",
-    "it.todo.only.skip",
-    "it.todo.sequential",
-    "it.todo.sequential.concurrent",
-    "it.todo.sequential.each",
-    "it.todo.sequential.fails",
-    "it.todo.sequential.only",
-    "it.todo.sequential.skip",
-    "it.todo.skip",
-    "it.todo.skip.concurrent",
-    "it.todo.skip.each",
-    "it.todo.skip.fails",
-    "it.todo.skip.only",
-    "it.todo.skip.sequential",
-    "suite",
-    "suite.concurrent",
-    "suite.concurrent.each",
-    "suite.concurrent.only",
-    "suite.concurrent.only.each",
-    "suite.concurrent.only.sequential",
-    "suite.concurrent.only.shuffle",
-    "suite.concurrent.only.skip",
-    "suite.concurrent.only.todo",
-    "suite.concurrent.sequential",
-    "suite.concurrent.sequential.each",
-    "suite.concurrent.sequential.only",
-    "suite.concurrent.sequential.shuffle",
-    "suite.concurrent.sequential.skip",
-    "suite.concurrent.sequential.todo",
-    "suite.concurrent.shuffle",
-    "suite.concurrent.shuffle.each",
-    "suite.concurrent.shuffle.only",
-    "suite.concurrent.shuffle.sequential",
-    "suite.concurrent.shuffle.skip",
-    "suite.concurrent.shuffle.todo",
-    "suite.concurrent.skip",
-    "suite.concurrent.skip.each",
-    "suite.concurrent.skip.only",
-    "suite.concurrent.skip.sequential",
-    "suite.concurrent.skip.shuffle",
-    "suite.concurrent.skip.todo",
-    "suite.concurrent.todo",
-    "suite.concurrent.todo.each",
-    "suite.concurrent.todo.only",
-    "suite.concurrent.todo.sequential",
-    "suite.concurrent.todo.shuffle",
-    "suite.concurrent.todo.skip",
-    "suite.each",
-    "suite.only",
-    "suite.only.concurrent",
-    "suite.only.concurrent.each",
-    "suite.only.concurrent.sequential",
-    "suite.only.concurrent.shuffle",
-    "suite.only.concurrent.skip",
-    "suite.only.concurrent.todo",
-    "suite.only.each",
-    "suite.only.sequential",
-    "suite.only.sequential.concurrent",
-    "suite.only.sequential.each",
-    "suite.only.sequential.shuffle",
-    "suite.only.sequential.skip",
-    "suite.only.sequential.todo",
-    "suite.only.shuffle",
-    "suite.only.shuffle.concurrent",
-    "suite.only.shuffle.each",
-    "suite.only.shuffle.sequential",
-    "suite.only.shuffle.skip",
-    "suite.only.shuffle.todo",
-    "suite.only.skip",
-    "suite.only.skip.concurrent",
-    "suite.only.skip.each",
-    "suite.only.skip.sequential",
-    "suite.only.skip.shuffle",
-    "suite.only.skip.todo",
-    "suite.only.todo",
-    "suite.only.todo.concurrent",
-    "suite.only.todo.each",
-    "suite.only.todo.sequential",
-    "suite.only.todo.shuffle",
-    "suite.only.todo.skip",
-    "suite.runIf",
-    "suite.runIf.concurrent",
-    "suite.runIf.concurrent.each",
-    "suite.runIf.concurrent.only",
-    "suite.runIf.concurrent.sequential",
-    "suite.runIf.concurrent.shuffle",
-    "suite.runIf.concurrent.skip",
-    "suite.runIf.concurrent.todo",
-    "suite.runIf.each",
-    "suite.runIf.only",
-    "suite.runIf.only.concurrent",
-    "suite.runIf.only.each",
-    "suite.runIf.only.sequential",
-    "suite.runIf.only.shuffle",
-    "suite.runIf.only.skip",
-    "suite.runIf.only.todo",
-    "suite.runIf.sequential",
-    "suite.runIf.sequential.concurrent",
-    "suite.runIf.sequential.each",
-    "suite.runIf.sequential.only",
-    "suite.runIf.sequential.shuffle",
-    "suite.runIf.sequential.skip",
-    "suite.runIf.sequential.todo",
-    "suite.runIf.shuffle",
-    "suite.runIf.shuffle.concurrent",
-    "suite.runIf.shuffle.each",
-    "suite.runIf.shuffle.only",
-    "suite.runIf.shuffle.sequential",
-    "suite.runIf.shuffle.skip",
-    "suite.runIf.shuffle.todo",
-    "suite.runIf.skip",
-    "suite.runIf.skip.concurrent",
-    "suite.runIf.skip.each",
-    "suite.runIf.skip.only",
-    "suite.runIf.skip.sequential",
-    "suite.runIf.skip.shuffle",
-    "suite.runIf.skip.todo",
-    "suite.runIf.todo",
-    "suite.runIf.todo.concurrent",
-    "suite.runIf.todo.each",
-    "suite.runIf.todo.only",
-    "suite.runIf.todo.sequential",
-    "suite.runIf.todo.shuffle",
-    "suite.runIf.todo.skip",
-    "suite.sequential",
-    "suite.sequential.concurrent",
-    "suite.sequential.concurrent.each",
-    "suite.sequential.concurrent.only",
-    "suite.sequential.concurrent.shuffle",
-    "suite.sequential.concurrent.skip",
-    "suite.sequential.concurrent.todo",
-    "suite.sequential.each",
-    "suite.sequential.only",
-    "suite.sequential.only.concurrent",
-    "suite.sequential.only.each",
-    "suite.sequential.only.shuffle",
-    "suite.sequential.only.skip",
-    "suite.sequential.only.todo",
-    "suite.sequential.shuffle",
-    "suite.sequential.shuffle.concurrent",
-    "suite.sequential.shuffle.each",
-    "suite.sequential.shuffle.only",
-    "suite.sequential.shuffle.skip",
-    "suite.sequential.shuffle.todo",
-    "suite.sequential.skip",
-    "suite.sequential.skip.concurrent",
-    "suite.sequential.skip.each",
-    "suite.sequential.skip.only",
-    "suite.sequential.skip.shuffle",
-    "suite.sequential.skip.todo",
-    "suite.sequential.todo",
-    "suite.sequential.todo.concurrent",
-    "suite.sequential.todo.each",
-    "suite.sequential.todo.only",
-    "suite.sequential.todo.shuffle",
-    "suite.sequential.todo.skip",
-    "suite.shuffle",
-    "suite.shuffle.concurrent",
-    "suite.shuffle.concurrent.each",
-    "suite.shuffle.concurrent.only",
-    "suite.shuffle.concurrent.sequential",
-    "suite.shuffle.concurrent.skip",
-    "suite.shuffle.concurrent.todo",
-    "suite.shuffle.each",
-    "suite.shuffle.only",
-    "suite.shuffle.only.concurrent",
-    "suite.shuffle.only.each",
-    "suite.shuffle.only.sequential",
-    "suite.shuffle.only.skip",
-    "suite.shuffle.only.todo",
-    "suite.shuffle.sequential",
-    "suite.shuffle.sequential.concurrent",
-    "suite.shuffle.sequential.each",
-    "suite.shuffle.sequential.only",
-    "suite.shuffle.sequential.skip",
-    "suite.shuffle.sequential.todo",
-    "suite.shuffle.skip",
-    "suite.shuffle.skip.concurrent",
-    "suite.shuffle.skip.each",
-    "suite.shuffle.skip.only",
-    "suite.shuffle.skip.sequential",
-    "suite.shuffle.skip.todo",
-    "suite.shuffle.todo",
-    "suite.shuffle.todo.concurrent",
-    "suite.shuffle.todo.each",
-    "suite.shuffle.todo.only",
-    "suite.shuffle.todo.sequential",
-    "suite.shuffle.todo.skip",
-    "suite.skip",
-    "suite.skip.concurrent",
-    "suite.skip.concurrent.each",
-    "suite.skip.concurrent.only",
-    "suite.skip.concurrent.sequential",
-    "suite.skip.concurrent.shuffle",
-    "suite.skip.concurrent.todo",
-    "suite.skip.each",
-    "suite.skip.only",
-    "suite.skip.only.concurrent",
-    "suite.skip.only.each",
-    "suite.skip.only.sequential",
-    "suite.skip.only.shuffle",
-    "suite.skip.only.todo",
-    "suite.skip.sequential",
-    "suite.skip.sequential.concurrent",
-    "suite.skip.sequential.each",
-    "suite.skip.sequential.only",
-    "suite.skip.sequential.shuffle",
-    "suite.skip.sequential.todo",
-    "suite.skip.shuffle",
-    "suite.skip.shuffle.concurrent",
-    "suite.skip.shuffle.each",
-    "suite.skip.shuffle.only",
-    "suite.skip.shuffle.sequential",
-    "suite.skip.shuffle.todo",
-    "suite.skip.todo",
-    "suite.skip.todo.concurrent",
-    "suite.skip.todo.each",
-    "suite.skip.todo.only",
-    "suite.skip.todo.sequential",
-    "suite.skip.todo.shuffle",
-    "suite.skipIf",
-    "suite.skipIf.concurrent",
-    "suite.skipIf.concurrent.each",
-    "suite.skipIf.concurrent.only",
-    "suite.skipIf.concurrent.sequential",
-    "suite.skipIf.concurrent.shuffle",
-    "suite.skipIf.concurrent.skip",
-    "suite.skipIf.concurrent.todo",
-    "suite.skipIf.each",
-    "suite.skipIf.only",
-    "suite.skipIf.only.concurrent",
-    "suite.skipIf.only.each",
-    "suite.skipIf.only.sequential",
-    "suite.skipIf.only.shuffle",
-    "suite.skipIf.only.skip",
-    "suite.skipIf.only.todo",
-    "suite.skipIf.sequential",
-    "suite.skipIf.sequential.concurrent",
-    "suite.skipIf.sequential.each",
-    "suite.skipIf.sequential.only",
-    "suite.skipIf.sequential.shuffle",
-    "suite.skipIf.sequential.skip",
-    "suite.skipIf.sequential.todo",
-    "suite.skipIf.shuffle",
-    "suite.skipIf.shuffle.concurrent",
-    "suite.skipIf.shuffle.each",
-    "suite.skipIf.shuffle.only",
-    "suite.skipIf.shuffle.sequential",
-    "suite.skipIf.shuffle.skip",
-    "suite.skipIf.shuffle.todo",
-    "suite.skipIf.skip",
-    "suite.skipIf.skip.concurrent",
-    "suite.skipIf.skip.each",
-    "suite.skipIf.skip.only",
-    "suite.skipIf.skip.sequential",
-    "suite.skipIf.skip.shuffle",
-    "suite.skipIf.skip.todo",
-    "suite.skipIf.todo",
-    "suite.skipIf.todo.concurrent",
-    "suite.skipIf.todo.each",
-    "suite.skipIf.todo.only",
-    "suite.skipIf.todo.sequential",
-    "suite.skipIf.todo.shuffle",
-    "suite.skipIf.todo.skip",
-    "suite.todo",
-    "suite.todo.concurrent",
-    "suite.todo.concurrent.each",
-    "suite.todo.concurrent.only",
-    "suite.todo.concurrent.sequential",
-    "suite.todo.concurrent.shuffle",
-    "suite.todo.concurrent.skip",
-    "suite.todo.each",
-    "suite.todo.only",
-    "suite.todo.only.concurrent",
-    "suite.todo.only.each",
-    "suite.todo.only.sequential",
-    "suite.todo.only.shuffle",
-    "suite.todo.only.skip",
-    "suite.todo.sequential",
-    "suite.todo.sequential.concurrent",
-    "suite.todo.sequential.each",
-    "suite.todo.sequential.only",
-    "suite.todo.sequential.shuffle",
-    "suite.todo.sequential.skip",
-    "suite.todo.shuffle",
-    "suite.todo.shuffle.concurrent",
-    "suite.todo.shuffle.each",
-    "suite.todo.shuffle.only",
-    "suite.todo.shuffle.sequential",
-    "suite.todo.shuffle.skip",
-    "suite.todo.skip",
-    "suite.todo.skip.concurrent",
-    "suite.todo.skip.each",
-    "suite.todo.skip.only",
-    "suite.todo.skip.sequential",
-    "suite.todo.skip.shuffle",
-    "test",
-    "test.concurrent",
-    "test.concurrent.each",
-    "test.concurrent.fails",
-    "test.concurrent.fails.each",
-    "test.concurrent.fails.only",
-    "test.concurrent.fails.sequential",
-    "test.concurrent.fails.skip",
-    "test.concurrent.fails.todo",
-    "test.concurrent.only",
-    "test.concurrent.only.each",
-    "test.concurrent.only.fails",
-    "test.concurrent.only.sequential",
-    "test.concurrent.only.skip",
-    "test.concurrent.only.todo",
-    "test.concurrent.sequential",
-    "test.concurrent.sequential.each",
-    "test.concurrent.sequential.fails",
-    "test.concurrent.sequential.only",
-    "test.concurrent.sequential.skip",
-    "test.concurrent.sequential.todo",
-    "test.concurrent.skip",
-    "test.concurrent.skip.each",
-    "test.concurrent.skip.fails",
-    "test.concurrent.skip.only",
-    "test.concurrent.skip.sequential",
-    "test.concurrent.skip.todo",
-    "test.concurrent.todo",
-    "test.concurrent.todo.each",
-    "test.concurrent.todo.fails",
-    "test.concurrent.todo.only",
-    "test.concurrent.todo.sequential",
-    "test.concurrent.todo.skip",
-    "test.each",
-    "test.extend",
-    "test.extend.concurrent",
-    "test.extend.concurrent.each",
-    "test.extend.concurrent.fails",
-    "test.extend.concurrent.only",
-    "test.extend.concurrent.sequential",
-    "test.extend.concurrent.skip",
-    "test.extend.concurrent.todo",
-    "test.extend.each",
-    "test.extend.fails",
-    "test.extend.fails.concurrent",
-    "test.extend.fails.each",
-    "test.extend.fails.only",
-    "test.extend.fails.sequential",
-    "test.extend.fails.skip",
-    "test.extend.fails.todo",
-    "test.extend.only",
-    "test.extend.only.concurrent",
-    "test.extend.only.each",
-    "test.extend.only.fails",
-    "test.extend.only.sequential",
-    "test.extend.only.skip",
-    "test.extend.only.todo",
-    "test.extend.runIf",
-    "test.extend.runIf.concurrent",
-    "test.extend.runIf.each",
-    "test.extend.runIf.fails",
-    "test.extend.runIf.only",
-    "test.extend.runIf.sequential",
-    "test.extend.runIf.skip",
-    "test.extend.runIf.todo",
-    "test.extend.sequential",
-    "test.extend.sequential.concurrent",
-    "test.extend.sequential.each",
-    "test.extend.sequential.fails",
-    "test.extend.sequential.only",
-    "test.extend.sequential.skip",
-    "test.extend.sequential.todo",
-    "test.extend.skip",
-    "test.extend.skip.concurrent",
-    "test.extend.skip.each",
-    "test.extend.skip.fails",
-    "test.extend.skip.only",
-    "test.extend.skip.sequential",
-    "test.extend.skip.todo",
-    "test.extend.skipIf",
-    "test.extend.skipIf.concurrent",
-    "test.extend.skipIf.each",
-    "test.extend.skipIf.fails",
-    "test.extend.skipIf.only",
-    "test.extend.skipIf.sequential",
-    "test.extend.skipIf.skip",
-    "test.extend.skipIf.todo",
-    "test.extend.todo",
-    "test.extend.todo.concurrent",
-    "test.extend.todo.each",
-    "test.extend.todo.fails",
-    "test.extend.todo.only",
-    "test.extend.todo.sequential",
-    "test.extend.todo.skip",
-    "test.fails",
-    "test.fails.concurrent",
-    "test.fails.concurrent.each",
-    "test.fails.concurrent.only",
-    "test.fails.concurrent.sequential",
-    "test.fails.concurrent.skip",
-    "test.fails.concurrent.todo",
-    "test.fails.each",
-    "test.fails.only",
-    "test.fails.only.concurrent",
-    "test.fails.only.each",
-    "test.fails.only.sequential",
-    "test.fails.only.skip",
-    "test.fails.only.todo",
-    "test.fails.sequential",
-    "test.fails.sequential.concurrent",
-    "test.fails.sequential.each",
-    "test.fails.sequential.only",
-    "test.fails.sequential.skip",
-    "test.fails.sequential.todo",
-    "test.fails.skip",
-    "test.fails.skip.concurrent",
-    "test.fails.skip.each",
-    "test.fails.skip.only",
-    "test.fails.skip.sequential",
-    "test.fails.skip.todo",
-    "test.fails.todo",
-    "test.fails.todo.concurrent",
-    "test.fails.todo.each",
-    "test.fails.todo.only",
-    "test.fails.todo.sequential",
-    "test.fails.todo.skip",
-    "test.only",
-    "test.only.concurrent",
-    "test.only.concurrent.each",
-    "test.only.concurrent.fails",
-    "test.only.concurrent.sequential",
-    "test.only.concurrent.skip",
-    "test.only.concurrent.todo",
-    "test.only.each",
-    "test.only.fails",
-    "test.only.fails.concurrent",
-    "test.only.fails.each",
-    "test.only.fails.sequential",
-    "test.only.fails.skip",
-    "test.only.fails.todo",
-    "test.only.sequential",
-    "test.only.sequential.concurrent",
-    "test.only.sequential.each",
-    "test.only.sequential.fails",
-    "test.only.sequential.skip",
-    "test.only.sequential.todo",
-    "test.only.skip",
-    "test.only.skip.concurrent",
-    "test.only.skip.each",
-    "test.only.skip.fails",
-    "test.only.skip.sequential",
-    "test.only.skip.todo",
-    "test.only.todo",
-    "test.only.todo.concurrent",
-    "test.only.todo.each",
-    "test.only.todo.fails",
-    "test.only.todo.sequential",
-    "test.only.todo.skip",
-    "test.runIf",
-    "test.runIf.concurrent",
-    "test.runIf.concurrent.each",
-    "test.runIf.concurrent.fails",
-    "test.runIf.concurrent.only",
-    "test.runIf.concurrent.sequential",
-    "test.runIf.concurrent.skip",
-    "test.runIf.concurrent.todo",
-    "test.runIf.each",
-    "test.runIf.fails",
-    "test.runIf.fails.concurrent",
-    "test.runIf.fails.each",
-    "test.runIf.fails.only",
-    "test.runIf.fails.sequential",
-    "test.runIf.fails.skip",
-    "test.runIf.fails.todo",
-    "test.runIf.only",
-    "test.runIf.only.concurrent",
-    "test.runIf.only.each",
-    "test.runIf.only.fails",
-    "test.runIf.only.sequential",
-    "test.runIf.only.skip",
-    "test.runIf.only.todo",
-    "test.runIf.sequential",
-    "test.runIf.sequential.concurrent",
-    "test.runIf.sequential.each",
-    "test.runIf.sequential.fails",
-    "test.runIf.sequential.only",
-    "test.runIf.sequential.skip",
-    "test.runIf.sequential.todo",
-    "test.runIf.skip",
-    "test.runIf.skip.concurrent",
-    "test.runIf.skip.each",
-    "test.runIf.skip.fails",
-    "test.runIf.skip.only",
-    "test.runIf.skip.sequential",
-    "test.runIf.skip.todo",
-    "test.runIf.todo",
-    "test.runIf.todo.concurrent",
-    "test.runIf.todo.each",
-    "test.runIf.todo.fails",
-    "test.runIf.todo.only",
-    "test.runIf.todo.sequential",
-    "test.runIf.todo.skip",
-    "test.sequential",
-    "test.sequential.concurrent",
-    "test.sequential.concurrent.each",
-    "test.sequential.concurrent.fails",
-    "test.sequential.concurrent.only",
-    "test.sequential.concurrent.skip",
-    "test.sequential.concurrent.todo",
-    "test.sequential.each",
-    "test.sequential.fails",
-    "test.sequential.fails.concurrent",
-    "test.sequential.fails.each",
-    "test.sequential.fails.only",
-    "test.sequential.fails.skip",
-    "test.sequential.fails.todo",
-    "test.sequential.only",
-    "test.sequential.only.concurrent",
-    "test.sequential.only.each",
-    "test.sequential.only.fails",
-    "test.sequential.only.skip",
-    "test.sequential.only.todo",
-    "test.sequential.skip",
-    "test.sequential.skip.concurrent",
-    "test.sequential.skip.each",
-    "test.sequential.skip.fails",
-    "test.sequential.skip.only",
-    "test.sequential.skip.todo",
-    "test.sequential.todo",
-    "test.sequential.todo.concurrent",
-    "test.sequential.todo.each",
-    "test.sequential.todo.fails",
-    "test.sequential.todo.only",
-    "test.sequential.todo.skip",
-    "test.skip",
-    "test.skip.concurrent",
-    "test.skip.concurrent.each",
-    "test.skip.concurrent.fails",
-    "test.skip.concurrent.only",
-    "test.skip.concurrent.sequential",
-    "test.skip.concurrent.todo",
-    "test.skip.each",
-    "test.skip.fails",
-    "test.skip.fails.concurrent",
-    "test.skip.fails.each",
-    "test.skip.fails.only",
-    "test.skip.fails.sequential",
-    "test.skip.fails.todo",
-    "test.skip.only",
-    "test.skip.only.concurrent",
-    "test.skip.only.each",
-    "test.skip.only.fails",
-    "test.skip.only.sequential",
-    "test.skip.only.todo",
-    "test.skip.sequential",
-    "test.skip.sequential.concurrent",
-    "test.skip.sequential.each",
-    "test.skip.sequential.fails",
-    "test.skip.sequential.only",
-    "test.skip.sequential.todo",
-    "test.skip.todo",
-    "test.skip.todo.concurrent",
-    "test.skip.todo.each",
-    "test.skip.todo.fails",
-    "test.skip.todo.only",
-    "test.skip.todo.sequential",
-    "test.skipIf",
-    "test.skipIf.concurrent",
-    "test.skipIf.concurrent.each",
-    "test.skipIf.concurrent.fails",
-    "test.skipIf.concurrent.only",
-    "test.skipIf.concurrent.sequential",
-    "test.skipIf.concurrent.skip",
-    "test.skipIf.concurrent.todo",
-    "test.skipIf.each",
-    "test.skipIf.fails",
-    "test.skipIf.fails.concurrent",
-    "test.skipIf.fails.each",
-    "test.skipIf.fails.only",
-    "test.skipIf.fails.sequential",
-    "test.skipIf.fails.skip",
-    "test.skipIf.fails.todo",
-    "test.skipIf.only",
-    "test.skipIf.only.concurrent",
-    "test.skipIf.only.each",
-    "test.skipIf.only.fails",
-    "test.skipIf.only.sequential",
-    "test.skipIf.only.skip",
-    "test.skipIf.only.todo",
-    "test.skipIf.sequential",
-    "test.skipIf.sequential.concurrent",
-    "test.skipIf.sequential.each",
-    "test.skipIf.sequential.fails",
-    "test.skipIf.sequential.only",
-    "test.skipIf.sequential.skip",
-    "test.skipIf.sequential.todo",
-    "test.skipIf.skip",
-    "test.skipIf.skip.concurrent",
-    "test.skipIf.skip.each",
-    "test.skipIf.skip.fails",
-    "test.skipIf.skip.only",
-    "test.skipIf.skip.sequential",
-    "test.skipIf.skip.todo",
-    "test.skipIf.todo",
-    "test.skipIf.todo.concurrent",
-    "test.skipIf.todo.each",
-    "test.skipIf.todo.fails",
-    "test.skipIf.todo.only",
-    "test.skipIf.todo.sequential",
-    "test.skipIf.todo.skip",
-    "test.todo",
-    "test.todo.concurrent",
-    "test.todo.concurrent.each",
-    "test.todo.concurrent.fails",
-    "test.todo.concurrent.only",
-    "test.todo.concurrent.sequential",
-    "test.todo.concurrent.skip",
-    "test.todo.each",
-    "test.todo.fails",
-    "test.todo.fails.concurrent",
-    "test.todo.fails.each",
-    "test.todo.fails.only",
-    "test.todo.fails.sequential",
-    "test.todo.fails.skip",
-    "test.todo.only",
-    "test.todo.only.concurrent",
-    "test.todo.only.each",
-    "test.todo.only.fails",
-    "test.todo.only.sequential",
-    "test.todo.only.skip",
-    "test.todo.sequential",
-    "test.todo.sequential.concurrent",
-    "test.todo.sequential.each",
-    "test.todo.sequential.fails",
-    "test.todo.sequential.only",
-    "test.todo.sequential.skip",
-    "test.todo.skip",
-    "test.todo.skip.concurrent",
-    "test.todo.skip.each",
-    "test.todo.skip.fails",
-    "test.todo.skip.only",
-    "test.todo.skip.sequential",
-    "xdescribe",
-    "xdescribe.each",
-    "xit",
-    "xit.each",
-    "xtest",
-    "xtest.each",
-];
+        // extend must be first
+        assert!(!is_valid_vitest_call(&["it", "concurrent", "extend"]));
+        // each must be last
+        assert!(!is_valid_vitest_call(&["it", "each", "only"]));
+        // Invalid: duplicates
+        assert!(!is_valid_vitest_call(&["it", "only", "only"]));
+        // very long
+        assert!(is_valid_vitest_call(&[
+            "test",
+            "extend",
+            "concurrent",
+            "fails",
+            "only",
+            "sequential",
+            "todo",
+            "each"
+        ]));
+    }
 
-pub fn is_valid_vitest_call(members: &[Cow<str>]) -> bool {
-    VALID_VITEST_FN_CALL_CHAINS.contains(&members.join("."))
+    #[test]
+    fn test_invalid_base_functions() {
+        assert!(!is_valid_vitest_call(&["unknown"]));
+        assert!(!is_valid_vitest_call(&["foo"]));
+        assert!(!is_valid_vitest_call(&["console"]));
+    }
 }