@tishlang/tish-lsp 3.6.0 → 3.7.1

package/crates/tish_test/src/expect.rs

@@ -0,0 +1,977 @@
+//! Jest/Bun-shaped `expect` matchers.
+
+use tishlang_core::{
+    has_pending_throw, set_pending_throw, take_pending_throw, value_call, Arc, ObjectMap, Value,
+};
+
+use crate::assert::assertion_error;
+use crate::deep_equal::deep_strict_equal;
+
+fn fail(msg: String, actual: Value, expected: Option<Value>, op: &str) -> Value {
+    set_pending_throw(assertion_error(msg, Some(actual), expected, op, true));
+    Value::Null
+}
+
+fn is_truthy(v: &Value) -> bool {
+    match v {
+        Value::Null => false,
+        Value::Bool(b) => *b,
+        Value::Number(n) => *n != 0.0 && !n.is_nan(),
+        Value::String(s) => !s.is_empty(),
+        _ => true,
+    }
+}
+
+/// Can `value_call` actually invoke this? Objects are callable only via a `__call` member.
+pub(crate) fn is_callable(v: &Value) -> bool {
+    match v {
+        Value::Function(_) => true,
+        Value::Object(o) => o.borrow().strings.contains_key("__call"),
+        _ => false,
+    }
+}
+
+/// Human-readable text for a thrown value: `Error`-shaped objects report their `message`.
+fn error_text(err: &Value) -> String {
+    if let Value::Object(o) = err {
+        if let Some(Value::String(m)) = o.borrow().strings.get("message") {
+            return m.to_string();
+        }
+    }
+    err.to_display_string()
+}
+
+/// Does a thrown value satisfy `expected` (string substring, regex, `Error`-shaped object,
+/// or a deep-equal value)? Node/Jest semantics — the previous version accepted *any* throw.
+pub(crate) fn error_matches(err: &Value, expected: &Value) -> bool {
+    match expected {
+        Value::String(pat) => error_text(err).contains(pat.as_str()),
+        #[cfg(feature = "regex")]
+        Value::RegExp(re) => re.borrow_mut().test(&error_text(err)),
+        // `{ message, name, … }` — every listed field must match.
+        Value::Object(o) if !o.borrow().strings.contains_key(ASYMMETRIC_KEY) => {
+            let want = o.borrow();
+            if want.strings.is_empty() {
+                return deep_strict_equal(err, expected);
+            }
+            let Value::Object(got) = err else {
+                return false;
+            };
+            let got = got.borrow();
+            want.strings.iter().all(|(k, wv)| match got.strings.get(k) {
+                Some(gv) => deep_strict_equal(gv, wv),
+                None => false,
+            })
+        }
+        _ => deep_strict_equal(err, expected),
+    }
+}
+
+fn describe_error_matcher(expected: &Value) -> String {
+    match expected {
+        Value::String(s) => format!("a message containing {:?}", s.as_str()),
+        _ => expected.to_display_string(),
+    }
+}
+
+fn type_of_name(v: &Value) -> &'static str {
+    match v {
+        Value::Null => "null",
+        Value::Bool(_) => "boolean",
+        Value::Number(_) => "number",
+        Value::String(_) => "string",
+        Value::Symbol(_) => "symbol",
+        Value::Function(_) => "function",
+        _ => "object",
+    }
+}
+
+/// Resolve a `toHaveProperty` path (`"a.b.0"` or `["a", "b", 0]`) to its value.
+fn property_at(root: &Value, path: &Value) -> Option<Value> {
+    let segments: Vec<String> = match path {
+        Value::Array(a) => a.borrow().iter().map(|v| v.to_display_string()).collect(),
+        other => other
+            .to_display_string()
+            .split('.')
+            .map(|s| s.to_string())
+            .collect(),
+    };
+    let mut cur = root.clone();
+    for seg in segments {
+        cur = match &cur {
+            Value::Object(o) => o.borrow().strings.get(seg.as_str())?.clone(),
+            Value::Array(a) => {
+                let idx: usize = seg.parse().ok()?;
+                a.borrow().get(idx)?.clone()
+            }
+            Value::NumberArray(a) => {
+                let idx: usize = seg.parse().ok()?;
+                a.borrow().to_values().get(idx)?.clone()
+            }
+            _ => return None,
+        };
+    }
+    Some(cur)
+}
+
+fn length_of(v: &Value) -> Option<f64> {
+    match v {
+        Value::Array(a) => Some(a.borrow().len() as f64),
+        Value::NumberArray(a) => Some(a.borrow().len() as f64),
+        Value::String(s) => Some(s.chars().count() as f64),
+        Value::Object(o) => o.borrow().strings.get("length").and_then(|x| x.as_number()),
+        _ => None,
+    }
+}
+
+/// Resolve Jest/Bun mock metadata from `expect(fn)` / `expect(fn.mock)`.
+fn mock_meta(v: &Value) -> Option<Value> {
+    let Value::Object(o) = v else {
+        return None;
+    };
+    let b = o.borrow();
+    if b.strings.contains_key("calls") && b.strings.contains_key("callCount") {
+        return Some(v.clone());
+    }
+    b.strings.get("mock").cloned().and_then(|m| {
+        if let Value::Object(mo) = &m {
+            let mb = mo.borrow();
+            if mb.strings.contains_key("calls") {
+                return Some(m.clone());
+            }
+        }
+        None
+    })
+}
+
+fn mock_call_count(meta: &Value) -> f64 {
+    let Value::Object(o) = meta else {
+        return 0.0;
+    };
+    o.borrow()
+        .strings
+        .get("callCount")
+        .and_then(|v| v.as_number())
+        .unwrap_or(0.0)
+}
+
+fn mock_calls(meta: &Value) -> Vec<Value> {
+    let Value::Object(o) = meta else {
+        return Vec::new();
+    };
+    match o.borrow().strings.get("calls") {
+        Some(Value::Array(a)) => a.borrow().clone(),
+        _ => Vec::new(),
+    }
+}
+
+// `!(a > b)` and friends are deliberate: they are TRUE when either side is NaN, which is what
+// these matchers must report. `partial_cmp` would silently pass an incomparable pair.
+#[allow(clippy::neg_cmp_op_on_partial_ord)]
+fn matcher_object(actual: Value) -> Value {
+    let actual_be = actual.clone();
+    let actual_eq = actual.clone();
+    let actual_strict = actual.clone();
+    let actual_throw = actual.clone();
+    let actual_match = actual.clone();
+    let actual_contain = actual.clone();
+    let actual_null = actual.clone();
+    let actual_truthy = actual.clone();
+    let actual_falsy = actual.clone();
+    let actual_defined = actual.clone();
+    let actual_len = actual.clone();
+    let actual_gt = actual.clone();
+    let actual_gte = actual.clone();
+    let actual_lt = actual.clone();
+    let actual_lte = actual.clone();
+    let actual_snap = actual.clone();
+    let actual_called = actual.clone();
+    let actual_called_times = actual.clone();
+    let actual_called_with = actual.clone();
+    let actual_last_with = actual.clone();
+
+    let mut m = ObjectMap::default();
+    m.insert(
+        Arc::from("toBe"),
+        Value::native(move |args: &[Value]| {
+            let expected = args.first().cloned().unwrap_or(Value::Null);
+            if !actual_be.strict_eq(&expected) {
+                return fail(
+                    format!(
+                        "expect(received).toBe(expected)\n\nExpected: {}\nReceived: {}",
+                        expected.to_display_string(),
+                        actual_be.to_display_string()
+                    ),
+                    actual_be.clone(),
+                    Some(expected),
+                    "toBe",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toEqual"),
+        Value::native(move |args: &[Value]| {
+            let expected = args.first().cloned().unwrap_or(Value::Null);
+            if !deep_strict_equal(&actual_eq, &expected) {
+                return fail(
+                    format!(
+                        "expect(received).toEqual(expected)\n\nExpected: {}\nReceived: {}",
+                        expected.to_display_string(),
+                        actual_eq.to_display_string()
+                    ),
+                    actual_eq.clone(),
+                    Some(expected),
+                    "toEqual",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toStrictEqual"),
+        Value::native(move |args: &[Value]| {
+            let expected = args.first().cloned().unwrap_or(Value::Null);
+            if !deep_strict_equal(&actual_strict, &expected) {
+                return fail(
+                    format!(
+                        "expect(received).toStrictEqual(expected)\n\nExpected: {}\nReceived: {}",
+                        expected.to_display_string(),
+                        actual_strict.to_display_string()
+                    ),
+                    actual_strict.clone(),
+                    Some(expected),
+                    "toStrictEqual",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toThrow"),
+        Value::native(move |args: &[Value]| {
+            // A non-callable would make `value_call` set a pending throw, which used to read
+            // as "the code threw" and pass. Reject it up front instead.
+            if !is_callable(&actual_throw) {
+                return fail(
+                    format!(
+                        "expect(received).toThrow()\n\nReceived value is not a function: {}",
+                        actual_throw.to_display_string()
+                    ),
+                    actual_throw.clone(),
+                    None,
+                    "toThrow",
+                );
+            }
+            let _ = take_pending_throw();
+            let _ = value_call(&actual_throw, &[]);
+            if !has_pending_throw() {
+                return fail(
+                    "expect(received).toThrow()\n\nReceived function did not throw".into(),
+                    actual_throw.clone(),
+                    None,
+                    "toThrow",
+                );
+            }
+            let err = take_pending_throw().unwrap_or(Value::Null);
+            if let Some(expected) = args.first() {
+                if !error_matches(&err, expected) {
+                    return fail(
+                        format!(
+                            "expect(received).toThrow(expected)\n\nExpected: {}\nReceived: {}",
+                            describe_error_matcher(expected),
+                            error_text(&err)
+                        ),
+                        err,
+                        Some(expected.clone()),
+                        "toThrow",
+                    );
+                }
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toMatch"),
+        Value::native(move |args: &[Value]| {
+            let s = actual_match.to_display_string();
+            let pattern = args.first().cloned().unwrap_or(Value::Null);
+            let ok = match &pattern {
+                #[cfg(feature = "regex")]
+                Value::RegExp(r) => r.borrow_mut().test(&s),
+                Value::String(p) => s.contains(p.as_str()),
+                other => s.contains(&other.to_display_string()),
+            };
+            if !ok {
+                return fail(
+                    format!(
+                        "expect(received).toMatch(expected)\n\nExpected pattern: {}\nReceived: {}",
+                        pattern.to_display_string(),
+                        s
+                    ),
+                    actual_match.clone(),
+                    Some(pattern),
+                    "toMatch",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toContain"),
+        Value::native(move |args: &[Value]| {
+            let item = args.first().cloned().unwrap_or(Value::Null);
+            let ok = match &actual_contain {
+                Value::String(s) => s.as_str().contains(&item.to_display_string()),
+                Value::Array(a) => a.borrow().iter().any(|v| v.strict_eq(&item)),
+                Value::NumberArray(a) => a
+                    .borrow()
+                    .to_values()
+                    .iter()
+                    .any(|v| v.strict_eq(&item)),
+                _ => false,
+            };
+            if !ok {
+                return fail(
+                    format!(
+                        "expect(received).toContain(expected)\n\nExpected to contain: {}\nReceived: {}",
+                        item.to_display_string(),
+                        actual_contain.to_display_string()
+                    ),
+                    actual_contain.clone(),
+                    Some(item),
+                    "toContain",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toBeNull"),
+        Value::native(move |_args: &[Value]| {
+            if !matches!(actual_null, Value::Null) {
+                return fail(
+                    format!(
+                        "expect(received).toBeNull()\n\nReceived: {}",
+                        actual_null.to_display_string()
+                    ),
+                    actual_null.clone(),
+                    Some(Value::Null),
+                    "toBeNull",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toBeTruthy"),
+        Value::native(move |_args: &[Value]| {
+            if !is_truthy(&actual_truthy) {
+                return fail(
+                    format!(
+                        "expect(received).toBeTruthy()\n\nReceived: {}",
+                        actual_truthy.to_display_string()
+                    ),
+                    actual_truthy.clone(),
+                    None,
+                    "toBeTruthy",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toBeFalsy"),
+        Value::native(move |_args: &[Value]| {
+            if is_truthy(&actual_falsy) {
+                return fail(
+                    format!(
+                        "expect(received).toBeFalsy()\n\nReceived: {}",
+                        actual_falsy.to_display_string()
+                    ),
+                    actual_falsy.clone(),
+                    None,
+                    "toBeFalsy",
+                );
+            }
+            Value::Null
+        }),
+    );
+    // Tish has no `undefined`; `null` is the absence value, so these mirror `toBeNull`.
+    // Always-passing / always-failing versions were traps: ported Node suites got no signal.
+    m.insert(
+        Arc::from("toBeDefined"),
+        Value::native(move |_args: &[Value]| {
+            if matches!(actual_defined, Value::Null) {
+                return fail(
+                    "expect(received).toBeDefined()\n\nReceived: null".into(),
+                    actual_defined.clone(),
+                    None,
+                    "toBeDefined",
+                );
+            }
+            Value::Null
+        }),
+    );
+    let actual_undefined = actual.clone();
+    m.insert(
+        Arc::from("toBeUndefined"),
+        Value::native(move |_args: &[Value]| {
+            if !matches!(actual_undefined, Value::Null) {
+                return fail(
+                    format!(
+                        "expect(received).toBeUndefined()\n\nTish has no undefined; null is the absence value.\nReceived: {}",
+                        actual_undefined.to_display_string()
+                    ),
+                    actual_undefined.clone(),
+                    None,
+                    "toBeUndefined",
+                );
+            }
+            Value::Null
+        }),
+    );
+    let actual_close = actual.clone();
+    m.insert(
+        Arc::from("toBeCloseTo"),
+        Value::native(move |args: &[Value]| {
+            let expected = args.first().and_then(|v| v.as_number()).unwrap_or(0.0);
+            let digits = args.get(1).and_then(|v| v.as_number()).unwrap_or(2.0);
+            let act = actual_close.as_number().unwrap_or(f64::NAN);
+            // Jest/Bun: |a - b| < 10^-digits / 2. The un-halved form accepted values Jest rejects.
+            let prec = 10f64.powf(-digits.max(0.0)) / 2.0;
+            if !((act - expected).abs() < prec) {
+                return fail(
+                    format!(
+                        "expect(received).toBeCloseTo({expected}, {digits})\n\nReceived: {act}"
+                    ),
+                    actual_close.clone(),
+                    Some(Value::Number(expected)),
+                    "toBeCloseTo",
+                );
+            }
+            Value::Null
+        }),
+    );
+    let actual_match_obj = actual.clone();
+    m.insert(
+        Arc::from("toMatchObject"),
+        Value::native(move |args: &[Value]| {
+            let expected = args.first().cloned().unwrap_or(Value::Null);
+            if !crate::deep_equal::partial_deep_strict_equal(&actual_match_obj, &expected) {
+                return fail(
+                    format!(
+                        "expect(received).toMatchObject(expected)\n\nExpected: {}\nReceived: {}",
+                        expected.to_display_string(),
+                        actual_match_obj.to_display_string()
+                    ),
+                    actual_match_obj.clone(),
+                    Some(expected),
+                    "toMatchObject",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toHaveLength"),
+        Value::native(move |args: &[Value]| {
+            let expected = args.first().and_then(|v| v.as_number()).unwrap_or(0.0);
+            match length_of(&actual_len) {
+                Some(n) if (n - expected).abs() < f64::EPSILON => Value::Null,
+                Some(n) => fail(
+                    format!(
+                        "expect(received).toHaveLength({})\n\nReceived length: {}",
+                        expected, n
+                    ),
+                    actual_len.clone(),
+                    Some(Value::Number(expected)),
+                    "toHaveLength",
+                ),
+                None => fail(
+                    format!(
+                        "expect(received).toHaveLength()\n\nReceived value has no length: {}",
+                        actual_len.to_display_string()
+                    ),
+                    actual_len.clone(),
+                    Some(Value::Number(expected)),
+                    "toHaveLength",
+                ),
+            }
+        }),
+    );
+    m.insert(
+        Arc::from("toBeGreaterThan"),
+        Value::native(move |args: &[Value]| {
+            let exp = args.first().and_then(|v| v.as_number()).unwrap_or(0.0);
+            let act = actual_gt.as_number().unwrap_or(f64::NAN);
+            if !(act > exp) {
+                return fail(
+                    format!("expect({act}).toBeGreaterThan({exp})"),
+                    actual_gt.clone(),
+                    Some(Value::Number(exp)),
+                    "toBeGreaterThan",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toBeGreaterThanOrEqual"),
+        Value::native(move |args: &[Value]| {
+            let exp = args.first().and_then(|v| v.as_number()).unwrap_or(0.0);
+            let act = actual_gte.as_number().unwrap_or(f64::NAN);
+            if !(act >= exp) {
+                return fail(
+                    format!("expect({act}).toBeGreaterThanOrEqual({exp})"),
+                    actual_gte.clone(),
+                    Some(Value::Number(exp)),
+                    "toBeGreaterThanOrEqual",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toBeLessThan"),
+        Value::native(move |args: &[Value]| {
+            let exp = args.first().and_then(|v| v.as_number()).unwrap_or(0.0);
+            let act = actual_lt.as_number().unwrap_or(f64::NAN);
+            if !(act < exp) {
+                return fail(
+                    format!("expect({act}).toBeLessThan({exp})"),
+                    actual_lt.clone(),
+                    Some(Value::Number(exp)),
+                    "toBeLessThan",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toBeLessThanOrEqual"),
+        Value::native(move |args: &[Value]| {
+            let exp = args.first().and_then(|v| v.as_number()).unwrap_or(0.0);
+            let act = actual_lte.as_number().unwrap_or(f64::NAN);
+            if !(act <= exp) {
+                return fail(
+                    format!("expect({act}).toBeLessThanOrEqual({exp})"),
+                    actual_lte.clone(),
+                    Some(Value::Number(exp)),
+                    "toBeLessThanOrEqual",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toHaveBeenCalled"),
+        Value::native(move |_args: &[Value]| {
+            let Some(meta) = mock_meta(&actual_called) else {
+                return fail(
+                    "expect(...).toHaveBeenCalled() requires a mock or spy".into(),
+                    actual_called.clone(),
+                    None,
+                    "toHaveBeenCalled",
+                );
+            };
+            if mock_call_count(&meta) < 1.0 {
+                return fail(
+                    "expect(mock).toHaveBeenCalled()".into(),
+                    actual_called.clone(),
+                    None,
+                    "toHaveBeenCalled",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toHaveBeenCalledTimes"),
+        Value::native(move |args: &[Value]| {
+            let Some(meta) = mock_meta(&actual_called_times) else {
+                return fail(
+                    "expect(...).toHaveBeenCalledTimes() requires a mock or spy".into(),
+                    actual_called_times.clone(),
+                    None,
+                    "toHaveBeenCalledTimes",
+                );
+            };
+            let expected = args.first().and_then(|v| v.as_number()).unwrap_or(0.0);
+            let got = mock_call_count(&meta);
+            if got != expected {
+                return fail(
+                    format!("expect(mock).toHaveBeenCalledTimes({expected})\n\nReceived: {got}"),
+                    actual_called_times.clone(),
+                    Some(Value::Number(expected)),
+                    "toHaveBeenCalledTimes",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toHaveBeenCalledWith"),
+        Value::native(move |args: &[Value]| {
+            let Some(meta) = mock_meta(&actual_called_with) else {
+                return fail(
+                    "expect(...).toHaveBeenCalledWith() requires a mock or spy".into(),
+                    actual_called_with.clone(),
+                    None,
+                    "toHaveBeenCalledWith",
+                );
+            };
+            let expected = args.to_vec();
+            let ok = mock_calls(&meta).iter().any(|call| match call {
+                Value::Array(a) => {
+                    let got = a.borrow();
+                    got.len() == expected.len()
+                        && got
+                            .iter()
+                            .zip(expected.iter())
+                            .all(|(g, e)| deep_strict_equal(g, e))
+                }
+                _ => false,
+            });
+            if !ok {
+                return fail(
+                    format!(
+                        "expect(mock).toHaveBeenCalledWith({})\n\nNumber of calls: {}",
+                        expected
+                            .iter()
+                            .map(|v| v.to_display_string())
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                        mock_call_count(&meta)
+                    ),
+                    actual_called_with.clone(),
+                    None,
+                    "toHaveBeenCalledWith",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toHaveBeenLastCalledWith"),
+        Value::native(move |args: &[Value]| {
+            let Some(meta) = mock_meta(&actual_last_with) else {
+                return fail(
+                    "expect(...).toHaveBeenLastCalledWith() requires a mock or spy".into(),
+                    actual_last_with.clone(),
+                    None,
+                    "toHaveBeenLastCalledWith",
+                );
+            };
+            let expected = args.to_vec();
+            let calls = mock_calls(&meta);
+            let Some(last) = calls.last() else {
+                return fail(
+                    "expect(mock).toHaveBeenLastCalledWith(...)\n\nNumber of calls: 0".into(),
+                    actual_last_with.clone(),
+                    None,
+                    "toHaveBeenLastCalledWith",
+                );
+            };
+            let ok = match last {
+                Value::Array(a) => {
+                    let got = a.borrow();
+                    got.len() == expected.len()
+                        && got
+                            .iter()
+                            .zip(expected.iter())
+                            .all(|(g, e)| deep_strict_equal(g, e))
+                }
+                _ => false,
+            };
+            if !ok {
+                return fail(
+                    "expect(mock).toHaveBeenLastCalledWith(...)".into(),
+                    actual_last_with.clone(),
+                    None,
+                    "toHaveBeenLastCalledWith",
+                );
+            }
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("toMatchSnapshot"),
+        Value::native(move |args: &[Value]| {
+            let hint = args.first().map(|v| v.to_display_string());
+            crate::snapshots::match_snapshot(&actual_snap, hint.as_deref())
+        }),
+    );
+    let actual_nan = actual.clone();
+    m.insert(
+        Arc::from("toBeNaN"),
+        Value::native(move |_args: &[Value]| {
+            if !matches!(actual_nan, Value::Number(n) if n.is_nan()) {
+                return fail(
+                    format!(
+                        "expect(received).toBeNaN()\n\nReceived: {}",
+                        actual_nan.to_display_string()
+                    ),
+                    actual_nan.clone(),
+                    None,
+                    "toBeNaN",
+                );
+            }
+            Value::Null
+        }),
+    );
+    let actual_typeof = actual.clone();
+    m.insert(
+        Arc::from("toBeTypeOf"),
+        Value::native(move |args: &[Value]| {
+            let want = args
+                .first()
+                .map(|v| v.to_display_string())
+                .unwrap_or_default();
+            let got = type_of_name(&actual_typeof);
+            if got != want {
+                return fail(
+                    format!("expect(received).toBeTypeOf({want:?})\n\nReceived type: {got}"),
+                    actual_typeof.clone(),
+                    None,
+                    "toBeTypeOf",
+                );
+            }
+            Value::Null
+        }),
+    );
+    let actual_prop = actual.clone();
+    m.insert(
+        Arc::from("toHaveProperty"),
+        Value::native(move |args: &[Value]| {
+            let path = args.first().cloned().unwrap_or(Value::Null);
+            let Some(found) = property_at(&actual_prop, &path) else {
+                return fail(
+                    format!(
+                        "expect(received).toHaveProperty({})\n\nProperty not found on: {}",
+                        path.to_display_string(),
+                        actual_prop.to_display_string()
+                    ),
+                    actual_prop.clone(),
+                    None,
+                    "toHaveProperty",
+                );
+            };
+            if let Some(expected) = args.get(1) {
+                if !deep_strict_equal(&found, expected) {
+                    return fail(
+                        format!(
+                            "expect(received).toHaveProperty({}, expected)\n\nExpected: {}\nReceived: {}",
+                            path.to_display_string(),
+                            expected.to_display_string(),
+                            found.to_display_string()
+                        ),
+                        found,
+                        Some(expected.clone()),
+                        "toHaveProperty",
+                    );
+                }
+            }
+            Value::Null
+        }),
+    );
+    let actual_contain_eq = actual.clone();
+    m.insert(
+        Arc::from("toContainEqual"),
+        Value::native(move |args: &[Value]| {
+            let item = args.first().cloned().unwrap_or(Value::Null);
+            let items = match actual_contain_eq.clone().coerce_number_array() {
+                Value::Array(a) => a.borrow().clone(),
+                _ => Vec::new(),
+            };
+            if !items.iter().any(|v| deep_strict_equal(v, &item)) {
+                return fail(
+                    format!(
+                        "expect(received).toContainEqual(expected)\n\nExpected to contain: {}\nReceived: {}",
+                        item.to_display_string(),
+                        actual_contain_eq.to_display_string()
+                    ),
+                    actual_contain_eq.clone(),
+                    Some(item),
+                    "toContainEqual",
+                );
+            }
+            Value::Null
+        }),
+    );
+
+    // `toThrowError` is Jest's alias for `toThrow`.
+    if let Some(t) = m.get("toThrow").cloned() {
+        m.insert(Arc::from("toThrowError"), t);
+    }
+
+    attach_not(&mut m, actual);
+    Value::object(m)
+}
+
+/// Build `expect(x).not.*` by inverting each matcher via pending-throw polarity.
+fn attach_not(m: &mut ObjectMap, actual: Value) {
+    let mut not_map = ObjectMap::default();
+    let keys: Vec<Arc<str>> = m.keys().cloned().collect();
+    for key in keys {
+        // `.not.toMatchSnapshot()` would write (or diff-invert) a snapshot; Jest has no such
+        // matcher either.
+        if key.as_ref() == "not" || key.as_ref() == "toMatchSnapshot" {
+            continue;
+        }
+        let Some(matcher) = m.get(key.as_ref()).cloned() else {
+            continue;
+        };
+        let act = actual.clone();
+        let name = key.to_string();
+        not_map.insert(
+            Arc::clone(&key),
+            Value::native(move |args: &[Value]| {
+                let _ = take_pending_throw();
+                let _ = value_call(&matcher, args);
+                if has_pending_throw() {
+                    let _ = take_pending_throw();
+                    return Value::Null;
+                }
+                fail(
+                    format!("expect(received).not.{name}() expected matcher to fail"),
+                    act.clone(),
+                    None,
+                    &format!("not.{name}"),
+                )
+            }),
+        );
+    }
+    m.insert(Arc::from("not"), Value::object(not_map));
+}
+
+thread_local! {
+    static ASSERTIONS_MADE: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    /// From `expect.assertions(n)`.
+    static ASSERTIONS_EXPECTED: std::cell::Cell<Option<usize>> =
+        const { std::cell::Cell::new(None) };
+    /// From `expect.hasAssertions()` — "at least one".
+    static ASSERTIONS_AT_LEAST: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+}
+
+/// Reset the per-test assertion counters. Called by the runner before each test body.
+pub fn begin_test_assertions() {
+    ASSERTIONS_MADE.with(|c| c.set(0));
+    ASSERTIONS_EXPECTED.with(|c| c.set(None));
+    ASSERTIONS_AT_LEAST.with(|c| c.set(false));
+}
+
+/// Verify an `expect.assertions(n)` / `expect.hasAssertions()` contract for the test that just ran.
+pub fn check_test_assertions() -> Result<(), String> {
+    let made = ASSERTIONS_MADE.with(|c| c.get());
+    if ASSERTIONS_AT_LEAST.with(|c| c.get()) && made == 0 {
+        return Err("expect.hasAssertions(): no assertions were made".to_string());
+    }
+    if let Some(want) = ASSERTIONS_EXPECTED.with(|c| c.get()) {
+        if made != want {
+            return Err(format!(
+                "expect.assertions({want}): {made} assertion(s) were made"
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn expect_call(args: &[Value]) -> Value {
+    ASSERTIONS_MADE.with(|c| c.set(c.get() + 1));
+    let actual = args.first().cloned().unwrap_or(Value::Null);
+    matcher_object(actual)
+}
+
+fn asymmetric_any(args: &[Value]) -> Value {
+    let type_name = args
+        .first()
+        .map(|v| v.to_display_string())
+        .unwrap_or_else(|| "Object".into());
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from(ASYMMETRIC_KEY), Value::String("any".into()));
+    m.insert(Arc::from("typeName"), Value::String(type_name.into()));
+    Value::object(m)
+}
+
+fn asymmetric_object_containing(args: &[Value]) -> Value {
+    let sample = args.first().cloned().unwrap_or(Value::Null);
+    let mut m = ObjectMap::default();
+    m.insert(
+        Arc::from(ASYMMETRIC_KEY),
+        Value::String("objectContaining".into()),
+    );
+    m.insert(Arc::from("sample"), sample);
+    Value::object(m)
+}
+
+fn asymmetric_array_containing(args: &[Value]) -> Value {
+    let sample = args.first().cloned().unwrap_or(Value::Null);
+    let mut m = ObjectMap::default();
+    m.insert(
+        Arc::from(ASYMMETRIC_KEY),
+        Value::String("arrayContaining".into()),
+    );
+    m.insert(Arc::from("sample"), sample);
+    Value::object(m)
+}
+
+fn asymmetric_string_matching(args: &[Value]) -> Value {
+    let sample = args.first().cloned().unwrap_or(Value::Null);
+    let mut m = ObjectMap::default();
+    m.insert(
+        Arc::from(ASYMMETRIC_KEY),
+        Value::String("stringMatching".into()),
+    );
+    m.insert(Arc::from("sample"), sample);
+    Value::object(m)
+}
+
+/// Marker key for `expect.any` / `objectContaining` / … Deliberately *not* React's `$$typeof`,
+/// which a plain user object may legitimately carry — treating those as matchers made them
+/// compare unequal to everything.
+pub(crate) const ASYMMETRIC_KEY: &str = "__tishAsymmetricMatcher";
+
+/// Build the callable `expect` object.
+pub fn expect_object() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("__call"), Value::native(expect_call));
+    m.insert(
+        Arc::from("assertions"),
+        Value::native(|args: &[Value]| {
+            let n = args.first().and_then(|v| v.as_number()).unwrap_or(0.0);
+            ASSERTIONS_EXPECTED.with(|c| c.set(Some(n.max(0.0) as usize)));
+            Value::Null
+        }),
+    );
+    m.insert(
+        Arc::from("hasAssertions"),
+        Value::native(|_args: &[Value]| {
+            ASSERTIONS_AT_LEAST.with(|c| c.set(true));
+            Value::Null
+        }),
+    );
+    m.insert(Arc::from("any"), Value::native(asymmetric_any));
+    m.insert(
+        Arc::from("anything"),
+        Value::native(|_args: &[Value]| {
+            let mut o = ObjectMap::default();
+            o.insert(Arc::from(ASYMMETRIC_KEY), Value::String("anything".into()));
+            Value::object(o)
+        }),
+    );
+    m.insert(
+        Arc::from("objectContaining"),
+        Value::native(asymmetric_object_containing),
+    );
+    m.insert(
+        Arc::from("arrayContaining"),
+        Value::native(asymmetric_array_containing),
+    );
+    m.insert(
+        Arc::from("stringMatching"),
+        Value::native(asymmetric_string_matching),
+    );
+    Value::object(m)
+}