[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7872ZM96468MGEJSX6631CH":3,"skill-same:01M7872ZM96468MGEJSX6631CH":46},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":26,"commitSha":27,"skillDirectory":28,"forksCount":14,"repositoryHtmlUrl":29,"repositoryHomepageUrl":6,"ownerHtmlUrl":30,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":31,"install":32,"resources":45},"01M7872ZM96468MGEJSX6631CH","rust-testing",null,"Use ONLY when user explicitly requests Rust test code, cargo-test\u002Frstest\u002Fmockall configuration,\ntest failure diagnosis, or coverage improvement for Rust projects.\n\nTriggers: \"write test rust\", \"cargo test\", \"rstest\", \"mockall\", \"rust coverage\",\n\"cargo nextest\", \"cargo-llvm-cov\", \"proptest\", \"insta snapshot\", \"should_panic\".\n\nDo NOT activate for: general Rust coding without test context, borrow checker issues,\ncargo build errors, or crate dependency resolution outside test scope.","chenziyang110\u002Flaunchdeck","chenziyang110","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F43693913?v=4","01M7863EBWK1D0P6A29YGEMAS4","Robin11","01M7863ECM1VB6RXDMHTW90D2T",0,"MIT","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Frust-testing\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: rust-testing\ndescription: |\n  Use ONLY when user explicitly requests Rust test code, cargo-test\u002Frstest\u002Fmockall configuration,\n  test failure diagnosis, or coverage improvement for Rust projects.\n\n  Triggers: \"write test rust\", \"cargo test\", \"rstest\", \"mockall\", \"rust coverage\",\n  \"cargo nextest\", \"cargo-llvm-cov\", \"proptest\", \"insta snapshot\", \"should_panic\".\n\n  Do NOT activate for: general Rust coding without test context, borrow checker issues,\n  cargo build errors, or crate dependency resolution outside test scope.\norigin: ECC\n---\n\n# Rust Testing (Agent Skill)\n\nAgent-focused testing workflow for modern Rust (edition 2021+) using the built-in test framework with `rstest` for fixtures and parametrization.\n\n## When to Use\n\n- Writing new Rust tests or fixing existing tests\n- Designing unit\u002Fintegration test coverage for Rust components\n- Adding test coverage, CI gating, or regression protection\n- Configuring `cargo test` workflows for consistent execution\n- Investigating test failures or flaky behavior\n- Testing async code, proc macros, or FFI boundaries\n\n### When NOT to Use\n\n- Implementing new product features without test changes\n- Large-scale refactors unrelated to test coverage or failures\n- Performance tuning without test regressions to validate\n- Non-Rust projects or non-test tasks\n\n### Stop Conditions — When to ASK instead of generating\n\nBefore generating any test code, STOP and ask the user if:\n- The code under test has **zero testability** (pub(crate) only internals, unsafe blocks without safe wrappers, hard-coded file\u002Fnetwork)\n- **No test dependencies** exist in Cargo.toml dev-dependencies (rstest, mockall, tokio test-util)\n- The request is **ambiguous**: \"test my crate\" or \"add tests\" without specifying modules\n- A **required test dependency** (rstest, mockall, proptest) is not installed\n- The test would require **secrets, real credentials, or production database access**\n\n## Core Concepts\n\n- **TDD loop**: red → green → refactor (tests first, minimal fix, then cleanups).\n- **Module tests**: `#[cfg(test)] mod tests { ... }` co-located in source files.\n- **Integration tests**: `tests\u002F` directory for black-box testing.\n- **Test layout**: `src\u002F` for unit tests (inline), `tests\u002F` for integration, `tests\u002Fcommon\u002F` for shared helpers.\n- **Doc tests**: `\u002F\u002F\u002F ``` ... ``` ` for documentation-as-tests.\n- **CI signal**: `cargo test --all-targets --all-features` followed by `cargo test --doc`.\n\n## Agent Execution Protocol\n\nWhen this skill is activated, follow this exact execution sequence:\n\n### Phase 1: Context Analysis\nBefore writing any test code:\n1. Identify the Rust edition (2021+) and workspace structure (`Cargo.toml`).\n2. Check for existing test files (`#[cfg(test)]` blocks, `tests\u002F*.rs`) to infer style.\n3. Analyze the code under test: identify public API surface, `unsafe` blocks, async (`async`\u002F`.await`), and FFI boundaries.\n4. Determine request type: (a) new tests, (b) fixing broken tests, (c) coverage improvement, (d) flaky test diagnosis.\n\n### Phase 2: Strategy Selection\nBased on Phase 1, select the appropriate strategy:\n- **Pure functions \u002F utilities**: inline `#[cfg(test)] mod tests` with `assert_eq!`, no mocks.\n- **Trait-based dependencies**: use `mockall` (`#[automock]`) or hand-written test doubles.\n- **Async code**: use `#[tokio::test]` or `tokio::test` with controlled runtime.\n- **Integration tests**: place in `tests\u002F` directory for black-box testing.\n\n### Decision Tree (Complex Scenarios)\n\n```text\nQ1: External I\u002FO (filesystem, network, DB)?\n  → Yes → Q2\n  → No  → Pure unit test, no mocks needed\n\nQ2: Mockable via trait\u002Finterface?\n  → Yes → Mock at trait boundary (mockall #[automock])\n  → No  → Q3\n\nQ3: Needs real behavior (async runtime, Docker)?\n  → Yes → Integration test (tests\u002F directory, tokio runtime)\n  → No  → Hand-written test double\n\nQ4: Async (tokio, async-std)?\n  → Yes → #[tokio::test] with controlled runtime\n  → No  → Synchronous #[test] sufficient\n\nQ5: Snapshot\u002Fapproval testing?\n  → Yes → insta::assert_snapshot! \u002F assert_debug_snapshot!\n  → No  → Standard assert_eq!\u002Fassert!\n```\n\n### Phase 3: Test Case Design\nApply systematic test design before coding:\n1. **Happy path**: normal input → expected output.\n2. **Boundary values**: empty `Vec`, `None`, `0`, `usize::MAX`, empty strings, `NonZero*` types.\n3. **Error cases**: `Result::Err`, `Option::None`, panics (`#[should_panic]`), `unsafe` precondition violations.\n4. **Memory & concurrency**: ownership\u002Fborrowing edge cases, `Send`\u002F`Sync` bounds, deadlock scenarios.\n\n### Phase 4: Code Generation\nOutput tests in this exact structure:\n```\n#### Test Strategy Summary\n- [ ] Scope: Unit \u002F Integration \u002F Doc Test\n- [ ] Framework: built-in test + rstest + mockall (if needed)\n- [ ] Mocking: Yes\u002FNo — mockall \u002F manual trait impls\n- [ ] Edge cases covered: \u003Clist>\n\n#### Generated Test Code\n\u003Cfile_path>\n\u003Ccode>\n\n#### Running Commands\n```bash\ncargo test --all-targets --all-features\ncargo nextest run  # recommended parallel runner\ncargo test --doc\n```\n\n#### Coverage Impact (if applicable)\n- Estimated coverage change: \u003CX%>\n- Command to verify: `cargo llvm-cov --html`\n```\n\n### Phase 5: Verification Checklist\nBefore completing, verify:\n- [ ] Tests compile and pass (`cargo test`).\n- [ ] Each test has exactly one logical assertion focus.\n- [ ] Mocks are reset between tests (reconstruct in `setup` or use `rstest` fixtures).\n- [ ] No `thread::sleep` used for synchronization (use channels or `tokio::time::timeout`).\n- [ ] Flaky test guardrails applied (`testing.allocator`, deterministic seeds, `--test-threads=1` check).\n\n## TDD Workflow\n\nFollow the RED → GREEN → REFACTOR loop:\n\n1. **RED**: write a failing test that captures the new behavior\n2. **GREEN**: implement the smallest change to pass\n3. **REFACTOR**: clean up while tests stay green\n\n```rust\n\u002F\u002F src\u002Flib.rs\npub fn add(a: i32, b: i32) -> i32 { todo!() } \u002F\u002F stub for RED\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test] \u002F\u002F RED\n    fn adds_two_numbers() {\n        assert_eq!(add(2, 3), 5);\n    }\n}\n\n\u002F\u002F src\u002Flib.rs\npub fn add(a: i32, b: i32) -> i32 { \u002F\u002F GREEN\n    a + b\n}\n\n\u002F\u002F REFACTOR: simplify\u002Frename once tests pass\n```\n\n## Code Examples\n\n### Basic Unit Test\n\n```rust\n\u002F\u002F src\u002Flib.rs\npub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn adds_two_numbers() {\n        assert_eq!(add(2, 3), 5);\n    }\n}\n```\n\n### Test Fixtures (rstest)\n\n```rust\n\u002F\u002F src\u002Flib.rs\nuse rstest::rstest;\n\n#[derive(Debug, PartialEq)]\nstruct User {\n    name: String,\n}\n\nstruct UserStore {\n    users: Vec\u003CUser>,\n}\n\nimpl UserStore {\n    fn new() -> Self {\n        Self { users: Vec::new() }\n    }\n\n    fn seed(&mut self, users: Vec\u003CUser>) {\n        self.users.extend(users);\n    }\n\n    fn find(&self, name: &str) -> Option\u003C&User> {\n        self.users.iter().find(|u| u.name == name)\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n    use rstest::*;\n\n    #[fixture]\n    fn user_store() -> UserStore {\n        let mut store = UserStore::new();\n        store.seed(vec![\n            User { name: \"alice\".into() },\n            User { name: \"bob\".into() },\n        ]);\n        store\n    }\n\n    #[rstest]\n    fn finds_existing_user(user_store: UserStore) {\n        let user = user_store.find(\"alice\");\n        assert!(user.is_some());\n        assert_eq!(user.unwrap().name, \"alice\");\n    }\n}\n```\n\n### Parametrized Tests (rstest)\n\n```rust\n\u002F\u002F src\u002Flib.rs\nuse rstest::rstest;\n\n#[rstest]\n#[case(1, 2, 3)]\n#[case(-1, 1, 0)]\n#[case(0, 0, 0)]\n#[case(100, 200, 300)]\nfn test_add(#[case] a: i32, #[case] b: i32, #[case] expected: i32) {\n    assert_eq!(add(a, b), expected);\n}\n```\n\n### Mocking (mockall)\n\n```rust\n\u002F\u002F src\u002Flib.rs\n#[cfg(test)]\nuse mockall::automock;\n\n#[cfg_attr(test, automock)]\npub trait Notifier {\n    fn send(&self, message: &str);\n}\n\npub struct Service\u003CT: Notifier> {\n    notifier: T,\n}\n\nimpl\u003CT: Notifier> Service\u003CT> {\n    pub fn new(notifier: T) -> Self {\n        Self { notifier }\n    }\n\n    pub fn publish(&self, message: &str) {\n        self.notifier.send(message);\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn sends_notifications() {\n        let mut mock = MockNotifier::new();\n        mock.expect_send()\n            .with(predicate::eq(\"hello\"))\n            .times(1)\n            .return_const(());\n\n        let service = Service::new(mock);\n        service.publish(\"hello\");\n    }\n}\n\n\u002F\u002F Cargo.toml\n\u002F\u002F [dev-dependencies]\n\u002F\u002F mockall = \"0.13\"\n```\n\n### Async Test (tokio-test)\n\n```rust\n\u002F\u002F src\u002Flib.rs\nasync fn fetch_user(id: &str) -> Result\u003CUser, Error> {\n    Ok(User { name: \"alice\".into() })\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[tokio::test]\n    async fn test_fetch_user() {\n        let user = fetch_user(\"1\").await.unwrap();\n        assert_eq!(user.name, \"alice\");\n    }\n}\n```\n\n### Doc Test\n\n```rust\n\u002F\u002F\u002F Adds two numbers together.\n\u002F\u002F\u002F\n\u002F\u002F\u002F ```\n\u002F\u002F\u002F use my_crate::add;\n\u002F\u002F\u002F\n\u002F\u002F\u002F assert_eq!(add(2, 3), 5);\n\u002F\u002F\u002F ```\npub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}\n```\n\n### Integration Test\n\n```rust\n\u002F\u002F tests\u002Fintegration_test.rs\nuse my_crate::add;\n\n#[test]\nfn integration_add() {\n    assert_eq!(add(2, 3), 5);\n}\n```\n\n### Result-Based Test\n\n```rust\n#[test]\nfn returns_result() -> Result\u003C(), String> {\n    if 2 + 2 == 4 {\n        Ok(())\n    } else {\n        Err(\"math broke\".into())\n    }\n}\n```\n\n### Test for Panics\n\n```rust\n#[test]\n#[should_panic(expected = \"age must be non-negative\")]\nfn test_negative_age() {\n    validate_age(-1);\n}\n```\n\n## Cargo.toml Quickstart\n\n```toml\n[dev-dependencies]\nrstest = \"0.25\"\nmockall = \"0.13\"\ntokio = { version = \"1\", features = [\"test-util\", \"macros\"] }\npretty_assertions = \"1\"    # readable assertion diffs\nproptest = \"1\"             # property-based testing\n```\n\n## Running Tests\n\n```bash\ncargo test                             # all tests\ncargo test -- --nocapture              # show stdout\ncargo test test_add                    # run tests matching filter\ncargo test tests::test_add            # fully qualified name\ncargo test --test integration_test     # single integration file\ncargo test --doc                      # run doc tests only\ncargo test --all-features             # test with all features\ncargo test -p my_crate                # test specific package\ncargo nextest run                     # Install: cargo install cargo-nextest@0.9\ncargo nextest run --workspace         # all workspace packages\ncargo nextest run --retries 3         # retry flaky tests automatically\n```\n\n## Coverage\n\n```bash\n# Install: cargo install cargo-tarpaulin@0.31\ncargo tarpaulin --ignore-tests\ncargo tarpaulin --out Html --output-dir coverage\n```\n\n```bash\n# LLVM coverage (nightly)\nRUSTFLAGS=\"-C instrument-coverage\" cargo test\nllvm-profdata merge -sparse default.profdata -o coverage.profdata\nllvm-cov report --instr-profile=coverage.profdata --object target\u002Fdebug\u002Fmy_crate\n```\n\n```bash\n# cargo-llvm-cov (recommended)\n# Install: cargo install cargo-llvm-cov@0.6\ncargo llvm-cov --html\ncargo llvm-cov --lcov --output-path lcov.info  # for Codecov\u002Fcoveralls\n```\n\n## Debugging Failures\n\n1. Re-run with `--nocapture` to see stdout\u002Fstderr from tests.\n2. Use `RUST_BACKTRACE=1` or `RUST_BACKTRACE=full` for stack traces.\n3. Use `dbg!()` macro for quick variable inspection.\n4. Use `cargo test -- --test-threads=1` to isolate concurrency issues.\n5. Expand to full suite once the root cause is fixed.\n\n## CI\u002FCD Integration (GitHub Actions)\n\n```yaml\n# .github\u002Fworkflows\u002Ftest.yml\nname: Test\non: [push, pull_request]\njobs:\n  test:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions\u002Fcheckout@v4\n      - run: rustup update stable\n      - run: cargo install cargo-nextest cargo-llvm-cov\n      - run: cargo nextest run --workspace\n      - run: cargo llvm-cov --html\n```\n\n## Flaky Tests Guardrails\n\n- Never use `std::thread::sleep` for synchronization; use `tokio::time::timeout`.\n- Make temp directories unique with `tempfile::TempDir`.\n- Avoid real time, network, or external services in unit tests.\n- Use deterministic seeds for randomized inputs.\n- Run tests with `--test-threads=1` to check for concurrency issues.\n- Use `#[cfg(not(miri))]` to skip tests that don't work under Miri.\n\n## Test Case Design Patterns\n\nApply these systematic patterns before writing test code to ensure robust coverage beyond the happy path.\n\n### 1. Boundary Value Analysis\nTest at the edges of valid input domains: empty, zero, maximum, None, and just-outside valid ranges.\n\n```rust\n\u002F\u002F src\u002Flib.rs\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[rstest]\n    #[case(\"\")]\n    #[case(\" \")]\n    #[case(&\"a\".repeat(10001))]\n    fn rejects_invalid_input(#[case] input: &str) {\n        assert!(validate_input(input).is_err());\n    }\n}\n```\n\n### 2. Negative \u002F Error Case Testing\nVerify the system behaves correctly under invalid or unexpected conditions.\n\n```rust\n#[test]\nfn divide_by_zero_returns_error() {\n    assert_eq!(divide(10, 0), Err(DivideError::Zero));\n}\n```\n\n### 3. State-Based Testing\nFor objects with internal state, verify transitions between states are correct and irreversible where expected.\n\n```rust\n#[test]\nfn connection_state_transitions() {\n    let mut conn = Connection::new();\n    assert_eq!(conn.state(), State::Closed);\n    conn.open().unwrap();\n    assert_eq!(conn.state(), State::Open);\n    conn.close().unwrap();\n    assert_eq!(conn.state(), State::Closed);\n    \u002F\u002F Idempotency\n    conn.close().unwrap();\n    assert_eq!(conn.state(), State::Closed);\n}\n```\n\n## Common Test Smells to Avoid\n\n- **Assertion Roulette**: Many assertions without context, making failure diagnosis ambiguous. *Fix: Use `assert_eq!(actual, expected, \"context: {variable}\")` with descriptive messages.*\n- **Happy Path Bias**: Only testing successful scenarios, leaving error paths uncovered. *Fix: Test `Err(...)` variants, `None` values, `unwrap_err()`, `#[should_panic]`.*\n- **Mock Overdose**: Too many mocks hiding integration issues or coupling tests to implementation. *Fix: Mock only at trait boundaries; prefer real implementations for pure logic.*\n- **The Free Ride**: Tests that execute code but assert nothing meaningful. *Fix: Every test must have at least one specific, falsifiable assertion.*\n- **Obscure Test**: Complex test functions with no clear arrange\u002Fact\u002Fassert structure. *Fix: Follow AAA, separate fixture setup with `#[fixture]` (rstest).*\n- **Flaky Test**: Non-deterministic results from concurrency, IO, or allocator state. *Fix: Use `testing.allocator`, `--test-threads=1` for isolation, proptest for exhaustive input testing.*\n\n## Best Practices\n\n### DO\n\n- Keep tests deterministic and isolated\n- Co-locate unit tests in `#[cfg(test)] mod tests` within source files\n- Use `rstest` for fixtures and parametrized tests\n- Use `assert_eq!`, `assert_ne!`, `assert!` with descriptive messages\n- Write doc tests for public API documentation\n- Separate integration tests in `tests\u002F` directory\n- Use `pretty_assertions` for readable assertion diffs\n\n### DON'T\n\n- Don't use `thread::sleep` for synchronization\n- Don't depend on real time or network in unit tests\n- Don't test private implementation details through public API\n- Don't use `unwrap` in tests — use `expect(\"message\")` for context\n- Don't write overly large test functions — test one behavior per test\n- Don't ignore test helper duplication — share via `tests\u002Fcommon\u002Fmod.rs`\n\n### Common Pitfalls\n\n- **Using sleep for sync** → Use channels, `tokio::sync`, or `condvar`.\n- **Global mutable state** → Use `std::sync::OnceLock` or test-local setup.\n- **Flaky async tests** → Use `#[tokio::test]` with controlled runtime.\n- **Leaking env vars** → Use `temp_env::with_var` for scoped env var changes.\n- **Over-mocking** → Prefer real implementations for domain logic.\n- **Slow compile times** → Keep test code behind `#[cfg(test)]` to avoid bloat.\n- **Missing property tests** → Use `proptest` for invariant validation.\n- **Brittle doc tests** → Run `cargo test --doc` in CI separately.\n\n### Snapshot Testing (insta)\n\n```rust\n\u002F\u002F src\u002Flib.rs\n#[cfg(test)]\nmod tests {\n    use super::*;\n    use insta::assert_snapshot;\n\n    #[test]\n    fn output_matches_snapshot() {\n        let output = generate_html();\n        assert_snapshot!(output);\n    }\n}\n```\n\n```bash\ncargo test          # creates new snapshots\ncargo insta review  # interactively approve\u002Freject changes\ncargo insta accept  # accept all pending snapshots\n```\n\nAdd to `Cargo.toml`:\n```toml\n[dev-dependencies]\ninsta = \"1.42\"\n```\n\n## Optional Appendix: Property-Based Testing\n\n### proptest\n\n```rust\nuse proptest::prelude::*;\n\nfn add(a: i32, b: i32) -> i32 { a + b }\n\nproptest! {\n    #[test]\n    fn add_is_commutative(a in any::\u003Ci32>(), b in any::\u003Ci32>()) {\n        assert_eq!(add(a, b), add(b, a));\n    }\n}\n```\n\n### Mutation Testing (cargo-mutants)\n\n```bash\n# Install: cargo install cargo-mutants\ncargo mutants                # run mutation testing\ncargo mutants -- --package my_crate\n# Report: terminal output with mutant survival rate\n```\n\n> Mutation testing introduces code mutations (e.g., `+` → `-`, `&&` → `||`) and checks if tests catch them. A mutant that survives indicates a gap in test coverage. **Target ≤20% mutant survival rate.**\n\n## Alternatives\n\n- **Built-in `#[test]`**: sufficient for most unit tests.\n- **cargo-nextest**: faster parallel test runner with better failure output.\n- **cucumber_rust**: BDD\u002FGherkin-style tests for Rust.\n","# Rust Testing (Agent Skill)\n\nAgent-focused testing workflow for modern Rust (edition 2021+) using the built-in test framework with `rstest` for fixtures and parametrization.\n\n## When to Use\n\n- Writing new Rust tests or fixing existing tests\n- Designing unit\u002Fintegration test coverage for Rust components\n- Adding test coverage, CI gating, or regression protection\n- Configuring `cargo test` workflows for consistent execution\n- Investigating test failures or flaky behavior\n- Testing async code, proc macros, or FFI boundaries\n\n### When NOT to Use\n\n- Implementing new product features without test changes\n- Large-scale refactors unrelated to test coverage or failures\n- Performance tuning without test regressions to validate\n- Non-Rust projects or non-test tasks\n\n### Stop Conditions — When to ASK instead of generating\n\nBefore generating any test code, STOP and ask the user if:\n- The code under test has **zero testability** (pub(crate) only internals, unsafe blocks without safe wrappers, hard-coded file\u002Fnetwork)\n- **No test dependencies** exist in Cargo.toml dev-dependencies (rstest, mockall, tokio test-util)\n- The request is **ambiguous**: \"test my crate\" or \"add tests\" without specifying modules\n- A **required test dependency** (rstest, mockall, proptest) is not installed\n- The test would require **secrets, real credentials, or production database access**\n\n## Core Concepts\n\n- **TDD loop**: red → green → refactor (tests first, minimal fix, then cleanups).\n- **Module tests**: `#[cfg(test)] mod tests { ... }` co-located in source files.\n- **Integration tests**: `tests\u002F` directory for black-box testing.\n- **Test layout**: `src\u002F` for unit tests (inline), `tests\u002F` for integration, `tests\u002Fcommon\u002F` for shared helpers.\n- **Doc tests**: `\u002F\u002F\u002F ``` ... ``` ` for documentation-as-tests.\n- **CI signal**: `cargo test --all-targets --all-features` followed by `cargo test --doc`.\n\n## Agent Execution Protocol\n\nWhen this skill is activated, follow this exact execution sequence:\n\n### Phase 1: Context Analysis\nBefore writing any test code:\n1. Identify the Rust edition (2021+) and workspace structure (`Cargo.toml`).\n2. Check for existing test files (`#[cfg(test)]` blocks, `tests\u002F*.rs`) to infer style.\n3. Analyze the code under test: identify public API surface, `unsafe` blocks, async (`async`\u002F`.await`), and FFI boundaries.\n4. Determine request type: (a) new tests, (b) fixing broken tests, (c) coverage improvement, (d) flaky test diagnosis.\n\n### Phase 2: Strategy Selection\nBased on Phase 1, select the appropriate strategy:\n- **Pure functions \u002F utilities**: inline `#[cfg(test)] mod tests` with `assert_eq!`, no mocks.\n- **Trait-based dependencies**: use `mockall` (`#[automock]`) or hand-written test doubles.\n- **Async code**: use `#[tokio::test]` or `tokio::test` with controlled runtime.\n- **Integration tests**: place in `tests\u002F` directory for black-box testing.\n\n### Decision Tree (Complex Scenarios)\n\n```text\nQ1: External I\u002FO (filesystem, network, DB)?\n  → Yes → Q2\n  → No  → Pure unit test, no mocks needed\n\nQ2: Mockable via trait\u002Finterface?\n  → Yes → Mock at trait boundary (mockall #[automock])\n  → No  → Q3\n\nQ3: Needs real behavior (async runtime, Docker)?\n  → Yes → Integration test (tests\u002F directory, tokio runtime)\n  → No  → Hand-written test double\n\nQ4: Async (tokio, async-std)?\n  → Yes → #[tokio::test] with controlled runtime\n  → No  → Synchronous #[test] sufficient\n\nQ5: Snapshot\u002Fapproval testing?\n  → Yes → insta::assert_snapshot! \u002F assert_debug_snapshot!\n  → No  → Standard assert_eq!\u002Fassert!\n```\n\n### Phase 3: Test Case Design\nApply systematic test design before coding:\n1. **Happy path**: normal input → expected output.\n2. **Boundary values**: empty `Vec`, `None`, `0`, `usize::MAX`, empty strings, `NonZero*` types.\n3. **Error cases**: `Result::Err`, `Option::None`, panics (`#[should_panic]`), `unsafe` precondition violations.\n4. **Memory & concurrency**: ownership\u002Fborrowing edge cases, `Send`\u002F`Sync` bounds, deadlock scenarios.\n\n### Phase 4: Code Generation\nOutput tests in this exact structure:\n```\n#### Test Strategy Summary\n- [ ] Scope: Unit \u002F Integration \u002F Doc Test\n- [ ] Framework: built-in test + rstest + mockall (if needed)\n- [ ] Mocking: Yes\u002FNo — mockall \u002F manual trait impls\n- [ ] Edge cases covered: \u003Clist>\n\n#### Generated Test Code\n\u003Cfile_path>\n\u003Ccode>\n\n#### Running Commands\n```bash\ncargo test --all-targets --all-features\ncargo nextest run  # recommended parallel runner\ncargo test --doc\n```\n\n#### Coverage Impact (if applicable)\n- Estimated coverage change: \u003CX%>\n- Command to verify: `cargo llvm-cov --html`\n```\n\n### Phase 5: Verification Checklist\nBefore completing, verify:\n- [ ] Tests compile and pass (`cargo test`).\n- [ ] Each test has exactly one logical assertion focus.\n- [ ] Mocks are reset between tests (reconstruct in `setup` or use `rstest` fixtures).\n- [ ] No `thread::sleep` used for synchronization (use channels or `tokio::time::timeout`).\n- [ ] Flaky test guardrails applied (`testing.allocator`, deterministic seeds, `--test-threads=1` check).\n\n## TDD Workflow\n\nFollow the RED → GREEN → REFACTOR loop:\n\n1. **RED**: write a failing test that captures the new behavior\n2. **GREEN**: implement the smallest change to pass\n3. **REFACTOR**: clean up while tests stay green\n\n```rust\n\u002F\u002F src\u002Flib.rs\npub fn add(a: i32, b: i32) -> i32 { todo!() } \u002F\u002F stub for RED\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test] \u002F\u002F RED\n    fn adds_two_numbers() {\n        assert_eq!(add(2, 3), 5);\n    }\n}\n\n\u002F\u002F src\u002Flib.rs\npub fn add(a: i32, b: i32) -> i32 { \u002F\u002F GREEN\n    a + b\n}\n\n\u002F\u002F REFACTOR: simplify\u002Frename once tests pass\n```\n\n## Code Examples\n\n### Basic Unit Test\n\n```rust\n\u002F\u002F src\u002Flib.rs\npub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn adds_two_numbers() {\n        assert_eq!(add(2, 3), 5);\n    }\n}\n```\n\n### Test Fixtures (rstest)\n\n```rust\n\u002F\u002F src\u002Flib.rs\nuse rstest::rstest;\n\n#[derive(Debug, PartialEq)]\nstruct User {\n    name: String,\n}\n\nstruct UserStore {\n    users: Vec\u003CUser>,\n}\n\nimpl UserStore {\n    fn new() -> Self {\n        Self { users: Vec::new() }\n    }\n\n    fn seed(&mut self, users: Vec\u003CUser>) {\n        self.users.extend(users);\n    }\n\n    fn find(&self, name: &str) -> Option\u003C&User> {\n        self.users.iter().find(|u| u.name == name)\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n    use rstest::*;\n\n    #[fixture]\n    fn user_store() -> UserStore {\n        let mut store = UserStore::new();\n        store.seed(vec![\n            User { name: \"alice\".into() },\n            User { name: \"bob\".into() },\n        ]);\n        store\n    }\n\n    #[rstest]\n    fn finds_existing_user(user_store: UserStore) {\n        let user = user_store.find(\"alice\");\n        assert!(user.is_some());\n        assert_eq!(user.unwrap().name, \"alice\");\n    }\n}\n```\n\n### Parametrized Tests (rstest)\n\n```rust\n\u002F\u002F src\u002Flib.rs\nuse rstest::rstest;\n\n#[rstest]\n#[case(1, 2, 3)]\n#[case(-1, 1, 0)]\n#[case(0, 0, 0)]\n#[case(100, 200, 300)]\nfn test_add(#[case] a: i32, #[case] b: i32, #[case] expected: i32) {\n    assert_eq!(add(a, b), expected);\n}\n```\n\n### Mocking (mockall)\n\n```rust\n\u002F\u002F src\u002Flib.rs\n#[cfg(test)]\nuse mockall::automock;\n\n#[cfg_attr(test, automock)]\npub trait Notifier {\n    fn send(&self, message: &str);\n}\n\npub struct Service\u003CT: Notifier> {\n    notifier: T,\n}\n\nimpl\u003CT: Notifier> Service\u003CT> {\n    pub fn new(notifier: T) -> Self {\n        Self { notifier }\n    }\n\n    pub fn publish(&self, message: &str) {\n        self.notifier.send(message);\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn sends_notifications() {\n        let mut mock = MockNotifier::new();\n        mock.expect_send()\n            .with(predicate::eq(\"hello\"))\n            .times(1)\n            .return_const(());\n\n        let service = Service::new(mock);\n        service.publish(\"hello\");\n    }\n}\n\n\u002F\u002F Cargo.toml\n\u002F\u002F [dev-dependencies]\n\u002F\u002F mockall = \"0.13\"\n```\n\n### Async Test (tokio-test)\n\n```rust\n\u002F\u002F src\u002Flib.rs\nasync fn fetch_user(id: &str) -> Result\u003CUser, Error> {\n    Ok(User { name: \"alice\".into() })\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[tokio::test]\n    async fn test_fetch_user() {\n        let user = fetch_user(\"1\").await.unwrap();\n        assert_eq!(user.name, \"alice\");\n    }\n}\n```\n\n### Doc Test\n\n```rust\n\u002F\u002F\u002F Adds two numbers together.\n\u002F\u002F\u002F\n\u002F\u002F\u002F ```\n\u002F\u002F\u002F use my_crate::add;\n\u002F\u002F\u002F\n\u002F\u002F\u002F assert_eq!(add(2, 3), 5);\n\u002F\u002F\u002F ```\npub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}\n```\n\n### Integration Test\n\n```rust\n\u002F\u002F tests\u002Fintegration_test.rs\nuse my_crate::add;\n\n#[test]\nfn integration_add() {\n    assert_eq!(add(2, 3), 5);\n}\n```\n\n### Result-Based Test\n\n```rust\n#[test]\nfn returns_result() -> Result\u003C(), String> {\n    if 2 + 2 == 4 {\n        Ok(())\n    } else {\n        Err(\"math broke\".into())\n    }\n}\n```\n\n### Test for Panics\n\n```rust\n#[test]\n#[should_panic(expected = \"age must be non-negative\")]\nfn test_negative_age() {\n    validate_age(-1);\n}\n```\n\n## Cargo.toml Quickstart\n\n```toml\n[dev-dependencies]\nrstest = \"0.25\"\nmockall = \"0.13\"\ntokio = { version = \"1\", features = [\"test-util\", \"macros\"] }\npretty_assertions = \"1\"    # readable assertion diffs\nproptest = \"1\"             # property-based testing\n```\n\n## Running Tests\n\n```bash\ncargo test                             # all tests\ncargo test -- --nocapture              # show stdout\ncargo test test_add                    # run tests matching filter\ncargo test tests::test_add            # fully qualified name\ncargo test --test integration_test     # single integration file\ncargo test --doc                      # run doc tests only\ncargo test --all-features             # test with all features\ncargo test -p my_crate                # test specific package\ncargo nextest run                     # Install: cargo install cargo-nextest@0.9\ncargo nextest run --workspace         # all workspace packages\ncargo nextest run --retries 3         # retry flaky tests automatically\n```\n\n## Coverage\n\n```bash\n# Install: cargo install cargo-tarpaulin@0.31\ncargo tarpaulin --ignore-tests\ncargo tarpaulin --out Html --output-dir coverage\n```\n\n```bash\n# LLVM coverage (nightly)\nRUSTFLAGS=\"-C instrument-coverage\" cargo test\nllvm-profdata merge -sparse default.profdata -o coverage.profdata\nllvm-cov report --instr-profile=coverage.profdata --object target\u002Fdebug\u002Fmy_crate\n```\n\n```bash\n# cargo-llvm-cov (recommended)\n# Install: cargo install cargo-llvm-cov@0.6\ncargo llvm-cov --html\ncargo llvm-cov --lcov --output-path lcov.info  # for Codecov\u002Fcoveralls\n```\n\n## Debugging Failures\n\n1. Re-run with `--nocapture` to see stdout\u002Fstderr from tests.\n2. Use `RUST_BACKTRACE=1` or `RUST_BACKTRACE=full` for stack traces.\n3. Use `dbg!()` macro for quick variable inspection.\n4. Use `cargo test -- --test-threads=1` to isolate concurrency issues.\n5. Expand to full suite once the root cause is fixed.\n\n## CI\u002FCD Integration (GitHub Actions)\n\n```yaml\n# .github\u002Fworkflows\u002Ftest.yml\nname: Test\non: [push, pull_request]\njobs:\n  test:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions\u002Fcheckout@v4\n      - run: rustup update stable\n      - run: cargo install cargo-nextest cargo-llvm-cov\n      - run: cargo nextest run --workspace\n      - run: cargo llvm-cov --html\n```\n\n## Flaky Tests Guardrails\n\n- Never use `std::thread::sleep` for synchronization; use `tokio::time::timeout`.\n- Make temp directories unique with `tempfile::TempDir`.\n- Avoid real time, network, or external services in unit tests.\n- Use deterministic seeds for randomized inputs.\n- Run tests with `--test-threads=1` to check for concurrency issues.\n- Use `#[cfg(not(miri))]` to skip tests that don't work under Miri.\n\n## Test Case Design Patterns\n\nApply these systematic patterns before writing test code to ensure robust coverage beyond the happy path.\n\n### 1. Boundary Value Analysis\nTest at the edges of valid input domains: empty, zero, maximum, None, and just-outside valid ranges.\n\n```rust\n\u002F\u002F src\u002Flib.rs\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[rstest]\n    #[case(\"\")]\n    #[case(\" \")]\n    #[case(&\"a\".repeat(10001))]\n    fn rejects_invalid_input(#[case] input: &str) {\n        assert!(validate_input(input).is_err());\n    }\n}\n```\n\n### 2. Negative \u002F Error Case Testing\nVerify the system behaves correctly under invalid or unexpected conditions.\n\n```rust\n#[test]\nfn divide_by_zero_returns_error() {\n    assert_eq!(divide(10, 0), Err(DivideError::Zero));\n}\n```\n\n### 3. State-Based Testing\nFor objects with internal state, verify transitions between states are correct and irreversible where expected.\n\n```rust\n#[test]\nfn connection_state_transitions() {\n    let mut conn = Connection::new();\n    assert_eq!(conn.state(), State::Closed);\n    conn.open().unwrap();\n    assert_eq!(conn.state(), State::Open);\n    conn.close().unwrap();\n    assert_eq!(conn.state(), State::Closed);\n    \u002F\u002F Idempotency\n    conn.close().unwrap();\n    assert_eq!(conn.state(), State::Closed);\n}\n```\n\n## Common Test Smells to Avoid\n\n- **Assertion Roulette**: Many assertions without context, making failure diagnosis ambiguous. *Fix: Use `assert_eq!(actual, expected, \"context: {variable}\")` with descriptive messages.*\n- **Happy Path Bias**: Only testing successful scenarios, leaving error paths uncovered. *Fix: Test `Err(...)` variants, `None` values, `unwrap_err()`, `#[should_panic]`.*\n- **Mock Overdose**: Too many mocks hiding integration issues or coupling tests to implementation. *Fix: Mock only at trait boundaries; prefer real implementations for pure logic.*\n- **The Free Ride**: Tests that execute code but assert nothing meaningful. *Fix: Every test must have at least one specific, falsifiable assertion.*\n- **Obscure Test**: Complex test functions with no clear arrange\u002Fact\u002Fassert structure. *Fix: Follow AAA, separate fixture setup with `#[fixture]` (rstest).*\n- **Flaky Test**: Non-deterministic results from concurrency, IO, or allocator state. *Fix: Use `testing.allocator`, `--test-threads=1` for isolation, proptest for exhaustive input testing.*\n\n## Best Practices\n\n### DO\n\n- Keep tests deterministic and isolated\n- Co-locate unit tests in `#[cfg(test)] mod tests` within source files\n- Use `rstest` for fixtures and parametrized tests\n- Use `assert_eq!`, `assert_ne!`, `assert!` with descriptive messages\n- Write doc tests for public API documentation\n- Separate integration tests in `tests\u002F` directory\n- Use `pretty_assertions` for readable assertion diffs\n\n### DON'T\n\n- Don't use `thread::sleep` for synchronization\n- Don't depend on real time or network in unit tests\n- Don't test private implementation details through public API\n- Don't use `unwrap` in tests — use `expect(\"message\")` for context\n- Don't write overly large test functions — test one behavior per test\n- Don't ignore test helper duplication — share via `tests\u002Fcommon\u002Fmod.rs`\n\n### Common Pitfalls\n\n- **Using sleep for sync** → Use channels, `tokio::sync`, or `condvar`.\n- **Global mutable state** → Use `std::sync::OnceLock` or test-local setup.\n- **Flaky async tests** → Use `#[tokio::test]` with controlled runtime.\n- **Leaking env vars** → Use `temp_env::with_var` for scoped env var changes.\n- **Over-mocking** → Prefer real implementations for domain logic.\n- **Slow compile times** → Keep test code behind `#[cfg(test)]` to avoid bloat.\n- **Missing property tests** → Use `proptest` for invariant validation.\n- **Brittle doc tests** → Run `cargo test --doc` in CI separately.\n\n### Snapshot Testing (insta)\n\n```rust\n\u002F\u002F src\u002Flib.rs\n#[cfg(test)]\nmod tests {\n    use super::*;\n    use insta::assert_snapshot;\n\n    #[test]\n    fn output_matches_snapshot() {\n        let output = generate_html();\n        assert_snapshot!(output);\n    }\n}\n```\n\n```bash\ncargo test          # creates new snapshots\ncargo insta review  # interactively approve\u002Freject changes\ncargo insta accept  # accept all pending snapshots\n```\n\nAdd to `Cargo.toml`:\n```toml\n[dev-dependencies]\ninsta = \"1.42\"\n```\n\n## Optional Appendix: Property-Based Testing\n\n### proptest\n\n```rust\nuse proptest::prelude::*;\n\nfn add(a: i32, b: i32) -> i32 { a + b }\n\nproptest! {\n    #[test]\n    fn add_is_commutative(a in any::\u003Ci32>(), b in any::\u003Ci32>()) {\n        assert_eq!(add(a, b), add(b, a));\n    }\n}\n```\n\n### Mutation Testing (cargo-mutants)\n\n```bash\n# Install: cargo install cargo-mutants\ncargo mutants                # run mutation testing\ncargo mutants -- --package my_crate\n# Report: terminal output with mutant survival rate\n```\n\n> Mutation testing introduces code mutations (e.g., `+` → `-`, `&&` → `||`) and checks if tests catch them. A mutant that survives indicates a gap in test coverage. **Target ≤20% mutant survival rate.**\n\n## Alternatives\n\n- **Built-in `#[test]`**: sufficient for most unit tests.\n- **cargo-nextest**: faster parallel test runner with better failure output.\n- **cucumber_rust**: BDD\u002FGherkin-style tests for Rust.\n",{"name":5,"origin":24,"description":25},"ECC","Use ONLY when user explicitly requests Rust test code, cargo-test\u002Frstest\u002Fmockall configuration,\ntest failure diagnosis, or coverage improvement for Rust projects.\n\nTriggers: \"write test rust\", \"cargo test\", \"rstest\", \"mockall\", \"rust coverage\",\n\"cargo nextest\", \"cargo-llvm-cov\", \"proptest\", \"insta snapshot\", \"should_panic\".\n\nDo NOT activate for: general Rust coding without test context, borrow checker issues,\ncargo build errors, or crate dependency resolution outside test scope.\n","main","021f5cbe02157229460a577e9a585f2da6d78cb0",".specify\u002Ftemplates\u002Fpassive-skills\u002Frust-testing","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck","https:\u002F\u002Fgithub.com\u002Fchenziyang110","2026-08-07 18:10:54",{"source":8,"skillName":5,"commands":33,"prompt":43,"zipAvailable":44},[34,37,40],{"tool":35,"command":36},"npx","npx skills add chenziyang110\u002Flaunchdeck --skill rust-testing",{"tool":38,"command":39},"bunx","bunx skills add chenziyang110\u002Flaunchdeck --skill rust-testing",{"tool":41,"command":42},"pnpm","pnpm dlx skills add chenziyang110\u002Flaunchdeck --skill rust-testing","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Frust-testing\u002FSKILL.md",true,[],[47,54,60,66,73,82],{"skillNo":48,"name":49,"nameZh":6,"description":50,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":51,"categories":52,"keywords":53,"publishedAt":19},"01M7875F3HQ1GF5F6BR36KY3JE","launchdeck-agent","Codex host adapter contract fixture for Launchdeck.","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002Ftest\u002Ffixtures\u002Fagent-hosts\u002Fcodex\u002Fskill\u002FSKILL.md",[],[],{"skillNo":55,"name":49,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":57,"categories":58,"keywords":59,"publishedAt":19},"01M7875DV2DQR33K1NFJHKAMZP","Claude host adapter contract fixture for Launchdeck.","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002Ftest\u002Ffixtures\u002Fagent-hosts\u002Fclaude\u002Fskill\u002FSKILL.md",[],[],{"skillNo":61,"name":49,"nameZh":6,"description":62,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":63,"categories":64,"keywords":65,"publishedAt":19},"01M78759JQ7A6FQ8KDQTNYS3X9","Use this skill aggressively for local project lifecycle operations even when the user does not mention Launchdeck: start this project, run the dev server, dev, build, test, restart service, stop service, show logs, inspect ports, port is occupied, clean cache; and when the user explicitly asks to configure this local project for Launchdeck or create or generate a project-adapted `.launchdeck.yml`, including 为这个项目生成 Launchdeck 配置. Do not use for ordinary code edits, docs-only work, general explanations, API design discussion, or production deployment unless the user also asks to operate or configure a local project or service.","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002Fagent\u002Finstaller-payload\u002Fskill\u002Flaunchdeck-agent\u002FSKILL.md",[],[],{"skillNo":67,"name":68,"nameZh":6,"description":69,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":19},"01M78753ZJQ7G2CZT1W1G8WRJV","zig-testing","Use ONLY when user explicitly requests Zig test code, built-in test runner configuration,\ntest failure diagnosis, or coverage for Zig projects.\n\nTriggers: \"write test zig\", \"zig test\", \"testing.allocator\", \"zig coverage\",\n\"comptime test\", \"zig expectError\", \"zig snapshot test\", \"zig fuzz\".\n\nDo NOT activate for: general Zig coding without test context, build.zig configuration\nfor non-test targets, Zig compiler errors, or Zig build system setup.","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Fzig-testing\u002FSKILL.md",[],[],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":77,"licenseFileUrl":78,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":19},"01M78750JXY4Z5D5W1EX3PQ31Z","webapp-testing","Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Fwebapp-testing\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Fwebapp-testing\u002FSKILL.md",[],[],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":19},"01M7874X2T83EQQFRCEY5SJJVC","verification-before-completion","Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Fverification-before-completion\u002FSKILL.md",[],[]]