Test Analysis Extensions

Rust Test Framework Reference (built-in #[test], cargo test)

Reference data for analyzing Rust test code. Used by the polyglot test analysis skills.

Capability tags

Test File Identification

Assertion APIs

Third-party libraries: pretty_assertions (assert_eq! with colored diffs), assert_matches, claim (assert_ok!, assert_err!).

Result-returning tests (Rust 2018+):

#[test]
fn parses_valid_input() -> Result<(), Box<dyn std::error::Error>> {
    let v = parse("1")?;
    assert_eq!(v, 1);
    Ok(())
}

Sleep/Delay Patterns

Skip/Ignore Annotations

Exception Handling — Idiomatic Alternatives

// should_panic with specific message:
#[test]
#[should_panic(expected = "must be positive")]
fn parses_negative_panics() {
    parse_amount(-5);
}

// Result return + ?:
#[test]
fn places_order_ok() -> anyhow::Result<()> {
    let order = service.place_order(valid_order())?;
    assert_eq!(order.id, 42);
    Ok(())
}

// Match on Err for specific variant:
let err = service.place_order(empty).unwrap_err();
assert!(matches!(err, OrderError::Empty));

Flag tests that use .unwrap() on Result returns from production code without asserting the error variant — they conflate "unexpected error" with test failure.

Mystery Guest — Common Rust Patterns

Integration Test Markers

• tests/ top-level directory contains integration tests

• Test names containing _integration_, _e2e_, _acceptance_

• Feature flags: #[cfg(feature = "integration-tests")]

• Crates like testcontainers imply integration

• cargo nextest profile names ([profile.integration])

Setup/Teardown

Rust has no native fixture framework. Common patterns:

Tag/Trait Attributes (for test-tagging)

Default mode: report-only / convention-based. Rust has no canonical per-test tag attribute. Strategies:

• Module grouping: mod positive { ... }, mod boundary { ... } — works with cargo test boundary::

• Test name prefixes: fn test_negative_invalid_input_returns_error() — filterable via cargo test negative_

• Feature flags for integration/E2E: #[cfg(feature = "e2e")]

• cargo nextest supports test groups via nextest.toml filtering expressions

Only switch to auto-edit mode when the project already follows one convention.

Language-specific calibration notes

• Doc tests are real tests — cargo test runs them. Treat as tests if user includes lib doc comments in scope.

• #[should_panic] without expected = "..." passes on ANY panic — that's a smell (overly broad).

• .unwrap() and .expect() in tests are acceptable for type-correct unwrapping but obscure error sources. Recommend ? on Result-returning tests where possible.

• Property-based tests (proptest!, quickcheck!) generate input cases; treat as parametrized tests, not duplicates.

• #[ignore] without a reason is a smell — flag as Ignored Test with low severity.

• Async tests requiring #[tokio::test] but missing it silently never run. Flag any async fn test missing the runtime attribute.

• thread::sleep in tests is a Sleepy Test; prefer tokio::time::pause() for async or explicit polling for sync.

• Tests that mutate static mut or global Mutex<...> state require #[serial] (from serial_test) — otherwise flaky under parallel cargo test.

• #[cfg(test)] modules cross-compiled with #![deny(warnings)] sometimes fail builds — note but don't flag as smell.

• Bare assert!(x) with no message in assert_eq!-suitable positions is acceptable; do not require messages.