[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-dotnet-test-smell-detection":3,"mdc--jcdddd-key":37,"related-org-dotnet-test-smell-detection":3291,"related-repo-dotnet-test-smell-detection":3453},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":25,"repoUrl":26,"updatedAt":27,"license":28,"forks":29,"topics":30,"repo":32,"sourceUrl":35,"mdContent":36},"test-smell-detection","audit tests for academic smells","Deep-dive audit using the full testsmells.org 19-smell academic catalog for tests in any language. Every finding maps to a named, citable smell from the research literature (Assertion Roulette, Duplicate Assert, Mystery Guest, Eager Test, Sensitive Equality, Conditional Test Logic, Sleepy Test, Magic Number Test, etc.) with research-backed severity. Polyglot: .NET (MSTest\u002FxUnit\u002FNUnit\u002FTUnit), Python (pytest\u002Funittest), TS\u002FJS (Jest\u002FVitest\u002FMocha\u002Fnode:test), Java (JUnit\u002FTestNG), Go, Ruby (RSpec\u002FMinitest), Rust, Swift, Kotlin (JUnit\u002FKotest), PowerShell (Pester), C++ (GoogleTest\u002FCatch2). INVOKE ONLY when explicitly asked for the testsmells.org 19-smell academic catalog or citable smell names from the literature. DO NOT USE FOR: general or pragmatic audits — use test-anti-patterns; writing new tests (use code-testing-agent, or writing-mstest-tests for MSTest); running tests (use run-tests); framework migration.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},"dotnet",".NET (Microsoft)","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Fdotnet.png",[12,16,19,22],{"name":13,"slug":14,"type":15},"Research","research","tag",{"name":17,"slug":18,"type":15},"Code Analysis","code-analysis",{"name":20,"slug":21,"type":15},"Testing","testing",{"name":23,"slug":24,"type":15},"Debugging","debugging",4576,"https:\u002F\u002Fgithub.com\u002Fdotnet\u002Fskills","2026-08-01T05:42:20.27086","MIT",332,[31],"agent-skills",{"repoUrl":26,"stars":25,"forks":29,"topics":33,"description":34},[31],"Repository for skills to assist AI coding agents with .NET and C#","https:\u002F\u002Fgithub.com\u002Fdotnet\u002Fskills\u002Ftree\u002FHEAD\u002Fplugins\u002Fdotnet-test\u002Fskills\u002Ftest-smell-detection","---\nname: test-smell-detection\ndescription: >\n  Deep-dive audit using the full testsmells.org 19-smell academic catalog\n  for tests in any language. Every finding maps to a named, citable smell\n  from the research literature (Assertion Roulette, Duplicate Assert,\n  Mystery Guest, Eager Test, Sensitive Equality, Conditional Test Logic,\n  Sleepy Test, Magic Number Test, etc.) with research-backed severity.\n  Polyglot: .NET (MSTest\u002FxUnit\u002FNUnit\u002FTUnit), Python (pytest\u002Funittest),\n  TS\u002FJS (Jest\u002FVitest\u002FMocha\u002Fnode:test), Java (JUnit\u002FTestNG), Go, Ruby\n  (RSpec\u002FMinitest), Rust, Swift, Kotlin (JUnit\u002FKotest), PowerShell\n  (Pester), C++ (GoogleTest\u002FCatch2).\n  INVOKE ONLY when explicitly asked for the testsmells.org 19-smell\n  academic catalog or citable smell names from the literature.\n  DO NOT USE FOR: general or pragmatic audits — use test-anti-patterns;\n  writing new tests (use code-testing-agent, or writing-mstest-tests for\n  MSTest); running tests (use run-tests); framework migration.\nlicense: MIT\n---\n\n# Test Smell Detection\n\nDeep formal audit of test code in any supported language using an academic test smell taxonomy. Detects symptoms of bad design or implementation decisions that make tests harder to understand, more fragile, less effective at catching bugs, or more expensive to maintain. Produces a severity-ranked report with specific locations and actionable fixes.\n\n> **Language-specific guidance**: Call the `test-analysis-extensions` skill to discover available extension files, then read the file matching the target codebase. The extension file documents test markers, sleep \u002F time \u002F random APIs, skip annotations, setup\u002Fteardown, mystery-guest indicators (file\u002Fdatabase\u002Fnetwork\u002Fenv), integration markers, and language-specific calibration notes that drive the smell detectors below.\n\n## Why Test Smells Matter\n\nTest smells erode confidence in a test suite and inflate maintenance costs:\n\n| Problem | Consequence |\n|---------|-------------|\n| Tests with conditional logic | Some paths never execute — hidden testing gaps |\n| Tests that depend on external resources | Flaky failures, slow execution, environment coupling |\n| Tests that sleep to wait for results | Non-deterministic timing, slow suites, false failures |\n| Tests without assertions | False confidence — coverage looks good but nothing is verified |\n| Tests that call many production methods | Hard to diagnose failures, unclear what's being tested |\n| Tests with magic numbers | Unreadable intent, unclear boundary conditions |\n| Tests relying on ToString for comparison | Brittle to formatting changes, obscure failure messages |\n| Tests with exception handling logic | Swallowed failures, tests that pass when they shouldn't |\n\n## When to Use\n\n- User asks for a comprehensive or formal test smell audit\n- User asks \"are my tests well-written?\" and wants a thorough analysis\n- User wants a test quality health check with academic rigor\n- User asks for a review of test design or structure using standard smell categories\n- User suspects tests are fragile, flaky, or giving false confidence and wants a deep investigation\n\n## When Not to Use\n\n- User wants a quick pragmatic test review (use `test-anti-patterns` — faster, covers the most common issues)\n- User wants to evaluate assertion diversity specifically (use `assertion-quality`)\n- User wants to find duplicated boilerplate across tests (use `exp-test-maintainability`)\n- User wants to write new tests from scratch (help them directly)\n- User wants to fix a specific failing test (diagnose and fix directly)\n\n## Inputs\n\n| Input | Required | Description |\n|-------|----------|-------------|\n| Test code | Yes | One or more test files or a test project directory to analyze |\n| Production code | No | The code under test, for context on whether patterns are justified |\n\n## Workflow\n\n### Step 1: Detect language and load extension\n\nIdentify the target codebase's language and test framework. Call the `test-analysis-extensions` skill and read the matching extension file (e.g., `extensions\u002Fdotnet.md`, `extensions\u002Fpython.md`, `extensions\u002Ftypescript.md`, `extensions\u002Fgo.md`). The extension file lists the framework-specific test markers, sleep \u002F wait APIs, skip \u002F ignore attributes, mystery-guest indicators, and integration-test markers that the smell detectors below need.\n\n### Step 2: Gather the test code\n\nRead all test files the user provides. If the user points to a directory or project, scan for all test files using the markers in the loaded language extension file.\n\nFor a thorough audit, also consult the [extended smell catalog](references\u002Ftest-smell-catalog.md) which covers 9 additional smell types beyond the core 10 below.\n\n### Step 3: Scan for test smells\n\nFor each test method and class, check for the following smell categories. Examples reference .NET attributes but the patterns apply across all supported languages — use the loaded language extension file to map each pattern to the framework you are auditing.\n\n#### Smell 1: Conditional Test Logic\n\nTest methods containing `if`, `else`, `switch`, ternary (`? :`), `for`, `foreach`, `while`, or pattern-match arms that change assertion behavior. Control flow in tests means some paths may never execute, hiding gaps.\n\n**Severity:** High\n**Detection:** Any control-flow statement inside a test method body that affects which assertions run.\n**Exceptions (per-language idioms, do NOT flag):**\n- **Foreach-assert** used solely to assert every item in a known collection (the assertion *is* the loop body).\n- **Go \u002F Rust table-driven tests**: `for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { ... }) }` (Go) or `#[rstest]` parametrized loops are idiomatic.\n- **`it.each(...)` \u002F `test.each(...)` \u002F `@pytest.mark.parametrize` \u002F `[Theory] + [InlineData]` \u002F `@ParameterizedTest`** parametrization driven by data tables.\n- **Pester `-ForEach` \u002F `-TestCases`** and **RSpec `where` blocks**.\n- **Catch2 `SECTION`s and `GENERATE(...)`**, **doctest `SUBCASE`**, **GoogleTest `INSTANTIATE_TEST_SUITE_P`**.\n\n#### Smell 2: Mystery Guest\n\nTests that depend on external resources — files on disk, databases, network endpoints, environment variables — without making the dependency explicit or using test doubles.\n\n**Severity:** High\n**Detection:** Test methods that read files, open database connections, make HTTP requests (without a test handler), read environment variables, or use hard-coded file paths. Per language: `File.ReadAllText` \u002F `Directory.GetFiles` \u002F `HttpClient` \u002F `Environment.GetEnvironmentVariable` (.NET); `open()` \u002F `pathlib.Path.read_text()` \u002F `requests.get()` \u002F `os.environ[...]` (Python); `fs.readFileSync` \u002F `fetch(...)` \u002F `process.env.X` (JS\u002FTS); `Files.readAllBytes` \u002F `Files.newInputStream` \u002F `HttpClient.send` \u002F `System.getenv` (Java); `os.ReadFile` \u002F `http.Get` \u002F `os.Getenv` (Go); `File.read` \u002F `Net::HTTP.get` \u002F `ENV[...]` (Ruby); `std::fs::read_to_string` \u002F `reqwest::get` \u002F `std::env::var` (Rust); `String(contentsOfFile:)` \u002F `URLSession.shared.data` \u002F `ProcessInfo.processInfo.environment` (Swift); `File(...).readText()` \u002F `URL(...).openConnection()` \u002F `System.getenv` (Kotlin); `Get-Content` \u002F `Invoke-WebRequest` \u002F `$env:X` (Pester); `std::ifstream` \u002F `curl_easy_perform` \u002F `std::getenv` (C++).\n**Exception:** In-memory fakes, test-specific handlers, or hermetic test data factories are fine.\n\n#### Smell 3: Sleepy Test\n\nTests that call sleep or delay functions to wait for a condition. These introduce non-deterministic timing and slow down the suite.\n\n**Severity:** High\n**Calibration:** Severity does **not** drop because the test is an integration test — a fixed sleep is still flaky and slow there. Report it as High and recommend polling\u002Fawaiting the condition with a timeout.\n**Detection:** Calls to sleep\u002Fdelay functions inside test methods: `Thread.Sleep` \u002F `Task.Delay` (.NET); `time.sleep` \u002F `asyncio.sleep` (Python); `setTimeout` \u002F `await new Promise(r => setTimeout(...))` \u002F `jest.advanceTimersByTime` not paired with a wait (JS\u002FTS); `Thread.sleep` \u002F `TimeUnit.SECONDS.sleep` (Java); `time.Sleep` (Go); `sleep` \u002F `Kernel#sleep` (Ruby); `std::thread::sleep` \u002F `tokio::time::sleep` (Rust); `Thread.sleep` \u002F `delay` (Kotlin coroutines); `sleep(_:)` \u002F `Task.sleep` (Swift); `Start-Sleep` (Pester); `std::this_thread::sleep_for` (C++). See the matching language extension file for the full list.\n\n#### Smell 4: Assertion-Free Test (Unknown Test)\n\nTests that execute code but never assert anything. Test frameworks report these as passing even if the code is completely broken, as long as no exception is thrown.\n\n**Severity:** High\n**Detection:** A test method with no assertion calls and no expected-exception annotation. Framework-specific: missing `Assert.*` (.NET); no `assert` \u002F `pytest.raises` (Python); no `expect(...)` or `assert.*` (JS\u002FTS); no `assert*` \u002F `assertThat` (Java); no `t.Error*` \u002F `t.Fatal*` \u002F `assert.*` testify (Go); no `expect`\u002F`.to`\u002F`.eq` (RSpec) or `assert*`\u002F`refute*` (Minitest); no `assert*!` \u002F `assert_eq!` \u002F `panic!` (Rust); no `XCTAssert*` \u002F `#expect` (Swift); no `assert*` \u002F `should*` \u002F Kotest matchers (Kotlin); no `Should -*` (Pester); no `EXPECT_*` \u002F `ASSERT_*` \u002F `REQUIRE` \u002F `CHECK` (C++).\n**Calibration:**\n- A method named `*_DoesNotThrow` \u002F `*_no_exception` \u002F `should not throw` is implicitly asserting no exception — still flag it but note it may be intentional.\n- **Mock-call verifications count as assertions**: `mock.Verify(...)` (Moq), `Mock.AssertWasCalled` (NSubstitute), `mock.assert_called_with(...)` (Python), `expect(mock).toHaveBeenCalledWith(...)` (Jest), `verify(mock).method(...)` (Mockito), `Should -Invoke` (Pester) — do NOT flag tests using these as assertion-free.\n- **Bare assertion forms count**: `assert x == y` (pytest), `if got != want { t.Errorf(...) }` (Go), `assert!(cond)` (Rust) are canonical.\n- **Snapshot assertions count**: `.toMatchSnapshot()` (Jest), `syrupy` (pytest), `SnapshotTesting` (Swift), `approval-tests` are real assertions.\n- **Missing await on async assertions is its own critical smell**: `expect(promise).resolves.toBe(x)` without `await`\u002F`return` (Jest), un-awaited `Assert.ThrowsAsync` (xUnit), un-awaited coroutines in `pytest-asyncio`, Kotest tests without `runTest`, Swift Testing async cases without `await`. These tests have assertion calls but silently pass — flag with a dedicated note.\n\n#### Smell 5: Eager Test\n\nA test method that calls many different production methods, making it unclear what behavior is being tested. When it fails, diagnosis is difficult because the failure could stem from any of the calls.\n\n**Severity:** Medium\n**Detection:** A test method that calls 4+ distinct methods on the production object (excluding setup\u002Fconstruction). Count unique method names, not call count.\n**Calibration:** Integration \u002F end-to-end \u002F workflow tests may legitimately call multiple methods. Check for integration markers in the loaded language extension file (e.g., `[Trait(\"Category\", \"Integration\")]`, `@Tag(\"integration\")`, `pytest.mark.integration`, `*_integration_test.go`, `Describe ... -Tag 'Integration'`) and downgrade.\n\n#### Smell 6: Magic Number Test\n\nAssertions that contain unexplained numeric literals. The intent of `Assert.AreEqual(42, result)` \u002F `assert result == 42` \u002F `expect(result).toBe(42)` is unclear without context — what does 42 represent?\n\n**Severity:** Medium\n**Detection:** Numeric literals (other than 0, 1, -1, and the literal used in the test name) appearing as `expected` parameters in assertion methods or comparison operands.\n**Calibration:** Small integers in context (like count checks `Assert.AreEqual(3, list.Count)` \u002F `assert len(items) == 3` \u002F `expect(arr.length).toBe(3)` where 3 items were just added) are acceptable — only flag when the number's meaning is genuinely unclear.\n\n#### Smell 7: Sensitive Equality\n\nTests that use string conversion for comparison or assertion. If the underlying string representation changes, the test breaks even though the actual behavior is correct.\n\n**Severity:** Medium\n**Detection:** `Assert.AreEqual(expected, obj.ToString())` (.NET); `assert str(obj) == \"...\"` or `assert repr(obj) == \"...\"` (Python); `expect(obj.toString()).toBe(\"...\")` or `expect(`${obj}`).toBe(...)` (JS\u002FTS); `assertEquals(expected, obj.toString())` (Java); `assert.Equal(t, \"...\", fmt.Sprint(obj))` or `obj.String()` chains (Go); `expect(obj.to_s).to eq(\"...\")` (RSpec); `assert_eq!(format!(\"{}\", obj), \"...\")` or `assert_eq!(format!(\"{:?}\", obj), \"...\")` (Rust); `XCTAssertEqual(obj.description, \"...\")` or string-interpolation assertion (Swift); `assertEquals(\"...\", obj.toString())` (Kotlin); `Should -Be \"...\"` against a `[string]$obj` (Pester); `EXPECT_EQ(\"...\", std::to_string(obj))` (C++).\n\n#### Smell 8: Exception Handling in Tests\n\nTests that contain `try`\u002F`catch`\u002F`except`\u002F`rescue` blocks or `throw`\u002F`raise`\u002F`panic`\u002F`return err` statements used to manage exception flow instead of asserting on it. This typically means the test is manually managing errors rather than using the framework's built-in exception assertion facilities.\n\n**Severity:** Medium\n**Detection:** `try`\u002F`catch` (.NET, Java, JS\u002FTS, Kotlin, Swift, C++); `try`\u002F`except` (Python); `begin`\u002F`rescue` (Ruby); `defer recover()` (Go); manual `if err != nil { t.Fatal(err) }` in Go is canonical and NOT a smell.\n**Exception:** `catch`\u002F`except`\u002F`rescue` blocks that capture an exception for further assertion on its properties are a lesser concern — note but don't flag as high severity.\n\n#### Smell 9: General Fixture (Over-broad Setup)\n\nThe test setup method, constructor, or fixture initializes fields that are not used by every test method. This means each test pays the cost of setting up objects it doesn't need.\n\n**Severity:** Low\n**Detection:** Fields\u002Fproperties initialized in `[TestInitialize]` \u002F `setUp` \u002F `@BeforeEach` \u002F `beforeEach` \u002F `before(:each)` \u002F `BeforeEach` (Pester) \u002F `setUpWithError` (XCTest) \u002F pytest `fixture(autouse=True)` \u002F xUnit constructor \u002F Kotest `beforeTest` that are referenced by fewer than half the test methods in the class\u002Fmodule\u002Ffile.\n\n#### Smell 10: Ignored \u002F Disabled \u002F Skipped Test\n\nTests marked as skipped or disabled. These add overhead and clutter, and the underlying issue they were disabled for may never be addressed.\n\n**Severity:** Low\n**Detection:** Skip \u002F ignore \u002F disable annotations or conditional compilation that disables a test. See the loaded language extension file for framework-specific skip attributes — e.g., `[Ignore]` (MSTest\u002FNUnit), `Skip = \"...\"` (xUnit `Fact`), `@Ignore` (TUnit\u002FJUnit 4), `@Disabled` (JUnit 5), `@pytest.mark.skip` \u002F `pytest.skip(...)` \u002F `pytestmark`, `it.skip` \u002F `xit` \u002F `describe.skip` \u002F `test.skip` (Jest\u002FVitest\u002FMocha), `t.Skip(...)` (Go), `pending` \u002F `skip` \u002F `xit` (RSpec), `#[ignore]` (Rust), `XCTSkip` \u002F `@Test(.disabled)` (Swift), `@Ignored` (Kotest), `-Skip` (Pester), `GTEST_SKIP()` \u002F `DISABLED_TestName` (GoogleTest), `[.]` tag (Catch2), `TEST_CASE(\"...\", \"[.]\")` skip.\n\n### Step 4: Apply calibration rules\n\nBefore reporting, calibrate findings to avoid false positives:\n\n- **Integration tests have different norms — but not for sleeps.** A test class clearly marked as integration (by name, annotation, category, or convention — see the loaded language extension file for markers) legitimately uses external resources and calls multiple methods. Downgrade Mystery Guest and Eager Test for integration tests. **Do NOT downgrade Sleepy Test:** a fixed wall-clock sleep is non-deterministic and slow in any test category, so it stays a real High-severity smell — recommend polling\u002Fawaiting the condition with a timeout instead. Only treat a sleep as acceptable when it is bounded by a documented external constraint (e.g. a third-party rate limit) *and* paired with a condition check.\n- **Simple loop-assert patterns are fine.** Iterating a collection to assert on every item is readable and correct. Only flag loops with complex branching logic.\n- **Idiomatic table-driven and parametrized patterns are NOT Conditional Test Logic.** Go's `for _, tt := range tests { t.Run(...) }`, Rust's `#[rstest]`, pytest's `@parametrize`, Jest\u002FVitest `.each`, JUnit `@ParameterizedTest`, RSpec `where`, Pester `-ForEach`, Catch2 `SECTION`\u002F`GENERATE`, GoogleTest `INSTANTIATE_TEST_SUITE_P` are canonical and must NOT be flagged.\n- **Context matters for magic numbers.** A count assertion right after adding a known number of items is self-documenting. Only flag numbers whose meaning requires looking at production code to understand.\n- **Bare `assert` (pytest) is canonical, not assertion-free framework use.** Don't flag.\n- **Go's `if err != nil { t.Fatal(err) }` is canonical**, not Exception Handling in Tests. Don't flag.\n- **Mock-call verifications and snapshot assertions are real assertions** — do not flag tests using them as Assertion-Free.\n- **Missing-await on async assertions is its own critical sub-smell of Assertion-Free** — these tests silently pass even when the underlying assertion fails. Always flag when detected.\n- **Inconclusive\u002Fpending markers are not assertion-free.** Tests explicitly marked as incomplete should be flagged as Ignored Test, not Assertion-Free.\n- **Capture-and-assert exception patterns are borderline.** `try { ... } catch (X x) { Assert.Equal(...) }` style patterns are ugly but functional. Note as a smell and suggest the framework's built-in exception assertion (`Assert.Throws\u003CT>`, `pytest.raises`, `expect(fn).toThrow`, `assertThrows`, `assert.PanicsWithError`, etc.) instead of calling it broken.\n- **If the test suite is clean, say so.** A report finding few or no smells is perfectly valid.\n\n### Step 5: Report findings\n\nPresent the analysis in this structure:\n\n1. **Summary Dashboard** — Quick overview:\n   ```\n   | Severity | Smell Count | Affected Tests |\n   |----------|-------------|----------------|\n   | High     | 3           | 7              |\n   | Medium   | 2           | 4              |\n   | Low      | 1           | 2              |\n   | Total    | 6           | 13             |\n   ```\n\n2. **Findings by Severity** — For each smell found:\n   - Smell name and category\n   - Severity level with rationale\n   - Affected test methods (file and method name)\n   - Code snippet showing the smell\n   - Concrete fix: show what the code should look like after remediation\n   - Risk if left unfixed\n\n3. **Smell-Free Patterns** — If any test methods are well-written, briefly acknowledge this. Highlighting what's good helps the user understand the contrast.\n\n4. **Prioritized Remediation Plan** — Rank fixes by:\n   - Impact (high-severity smells affecting many tests first)\n   - Effort (quick fixes before refactoring)\n   - Risk (fixes that prevent false-passes before cosmetic improvements)\n\n## Validation\n\n- [ ] Every finding includes the specific test method name and file location\n- [ ] Every finding includes a code snippet showing the smell in context\n- [ ] Every finding includes a concrete fix example (not just \"fix this\")\n- [ ] Integration tests are not penalized for using real resources, but their fixed sleeps are still reported as High\n- [ ] Each smell is reported under its own taxonomy name (Unknown Test, Empty Test, Assertion Roulette are distinct — do not merge them)\n- [ ] Simple foreach-assert loops are not flagged as conditional test logic\n- [ ] Contextually obvious numbers are not flagged as magic numbers\n- [ ] If the test suite is clean, the report says so upfront\n- [ ] Severity levels are justified, not arbitrary\n\n## Common Pitfalls\n\n| Pitfall | Solution |\n|---------|----------|\n| Flagging integration tests for using real resources | Check for integration test markers (per the loaded language extension) and adjust severity accordingly — external resources and multi-step flows are expected there |\n| Calibrating away a real sleep as an \"integration style issue\" | `Thread.Sleep(3000)` in an integration test is still a High-severity Sleepy Test; recommend a polled wait with timeout |\n| Flagging loop-over-collection-assert as conditional logic | Only flag loops with branching or complex logic, not assertion iterations |\n| Flagging Go\u002FRust table-driven loops as Conditional Test Logic | `for _, tt := range tests { t.Run(...) }` (Go) and `#[rstest]` loops (Rust) are canonical and must NOT be flagged |\n| Flagging parametrized tests as Duplicate Assert | `@pytest.mark.parametrize`, `it.each`, `[Theory]+[InlineData]`, `@ParameterizedTest`, RSpec `where`, Pester `-ForEach`, Catch2 `SECTION`\u002F`GENERATE` are correct deduplication, not smells |\n| Flagging obvious count assertions after adding N items | Consider the immediate context — self-documenting numbers are fine |\n| Missing framework-specific assertion syntax | Always read the matching language extension file first; each framework has distinct assertion APIs (xUnit `Assert.Equal`, MSTest `Assert.AreEqual`, NUnit `Is.EqualTo`, pytest bare `assert`, Jest `expect().toBe()`, etc.) |\n| Treating mock-call verifications as assertion-free | `mock.Verify(...)`, `expect(mock).toHaveBeenCalledWith(...)`, `Should -Invoke`, `verify(mock).method(...)`, `mock.assert_called_with(...)` are real assertions |\n| Missing the async-test silent-pass trap | Always flag `expect(promise).resolves.toBe(x)` without `await`\u002F`return`, un-awaited `Assert.ThrowsAsync` (xUnit), un-awaited coroutines in pytest-asyncio, missing `runTest` in Kotest, un-awaited Swift Testing async assertions |\n| Over-flagging try\u002Fcatch that captures for assertion | Distinguish swallowed exceptions from capture-and-assert patterns |\n| Treating skip annotations with reasons same as bare skips | Note that reasoned skips (`Skip = \"Tracked by #123\"`, `@pytest.mark.skip(reason=\"...\")`, `t.Skip(\"not yet implemented\")`) are less concerning than unexplained ones |\n| Flagging `DoesNotThrow`-style tests as assertion-free | These implicitly assert no exception — note but acknowledge the intent |\n",{"data":38,"body":39},{"name":4,"description":6,"license":28},{"type":40,"children":41},"root",[42,50,56,80,87,92,224,230,260,266,317,323,386,392,399,441,447,452,466,472,477,484,541,563,738,744,749,1032,1038,1043,1213,1219,1224,1441,1663,1669,1674,1731,1737,1764,1814,1820,1825,1964,1970,2033,2124,2130,2135,2217,2223,2228,2428,2434,2439,2695,2701,2706,2813,2819,2909,2915],{"type":43,"tag":44,"props":45,"children":46},"element","h1",{"id":4},[47],{"type":48,"value":49},"text","Test Smell Detection",{"type":43,"tag":51,"props":52,"children":53},"p",{},[54],{"type":48,"value":55},"Deep formal audit of test code in any supported language using an academic test smell taxonomy. Detects symptoms of bad design or implementation decisions that make tests harder to understand, more fragile, less effective at catching bugs, or more expensive to maintain. Produces a severity-ranked report with specific locations and actionable fixes.",{"type":43,"tag":57,"props":58,"children":59},"blockquote",{},[60],{"type":43,"tag":51,"props":61,"children":62},{},[63,69,71,78],{"type":43,"tag":64,"props":65,"children":66},"strong",{},[67],{"type":48,"value":68},"Language-specific guidance",{"type":48,"value":70},": Call the ",{"type":43,"tag":72,"props":73,"children":75},"code",{"className":74},[],[76],{"type":48,"value":77},"test-analysis-extensions",{"type":48,"value":79}," skill to discover available extension files, then read the file matching the target codebase. The extension file documents test markers, sleep \u002F time \u002F random APIs, skip annotations, setup\u002Fteardown, mystery-guest indicators (file\u002Fdatabase\u002Fnetwork\u002Fenv), integration markers, and language-specific calibration notes that drive the smell detectors below.",{"type":43,"tag":81,"props":82,"children":84},"h2",{"id":83},"why-test-smells-matter",[85],{"type":48,"value":86},"Why Test Smells Matter",{"type":43,"tag":51,"props":88,"children":89},{},[90],{"type":48,"value":91},"Test smells erode confidence in a test suite and inflate maintenance costs:",{"type":43,"tag":93,"props":94,"children":95},"table",{},[96,115],{"type":43,"tag":97,"props":98,"children":99},"thead",{},[100],{"type":43,"tag":101,"props":102,"children":103},"tr",{},[104,110],{"type":43,"tag":105,"props":106,"children":107},"th",{},[108],{"type":48,"value":109},"Problem",{"type":43,"tag":105,"props":111,"children":112},{},[113],{"type":48,"value":114},"Consequence",{"type":43,"tag":116,"props":117,"children":118},"tbody",{},[119,133,146,159,172,185,198,211],{"type":43,"tag":101,"props":120,"children":121},{},[122,128],{"type":43,"tag":123,"props":124,"children":125},"td",{},[126],{"type":48,"value":127},"Tests with conditional logic",{"type":43,"tag":123,"props":129,"children":130},{},[131],{"type":48,"value":132},"Some paths never execute — hidden testing gaps",{"type":43,"tag":101,"props":134,"children":135},{},[136,141],{"type":43,"tag":123,"props":137,"children":138},{},[139],{"type":48,"value":140},"Tests that depend on external resources",{"type":43,"tag":123,"props":142,"children":143},{},[144],{"type":48,"value":145},"Flaky failures, slow execution, environment coupling",{"type":43,"tag":101,"props":147,"children":148},{},[149,154],{"type":43,"tag":123,"props":150,"children":151},{},[152],{"type":48,"value":153},"Tests that sleep to wait for results",{"type":43,"tag":123,"props":155,"children":156},{},[157],{"type":48,"value":158},"Non-deterministic timing, slow suites, false failures",{"type":43,"tag":101,"props":160,"children":161},{},[162,167],{"type":43,"tag":123,"props":163,"children":164},{},[165],{"type":48,"value":166},"Tests without assertions",{"type":43,"tag":123,"props":168,"children":169},{},[170],{"type":48,"value":171},"False confidence — coverage looks good but nothing is verified",{"type":43,"tag":101,"props":173,"children":174},{},[175,180],{"type":43,"tag":123,"props":176,"children":177},{},[178],{"type":48,"value":179},"Tests that call many production methods",{"type":43,"tag":123,"props":181,"children":182},{},[183],{"type":48,"value":184},"Hard to diagnose failures, unclear what's being tested",{"type":43,"tag":101,"props":186,"children":187},{},[188,193],{"type":43,"tag":123,"props":189,"children":190},{},[191],{"type":48,"value":192},"Tests with magic numbers",{"type":43,"tag":123,"props":194,"children":195},{},[196],{"type":48,"value":197},"Unreadable intent, unclear boundary conditions",{"type":43,"tag":101,"props":199,"children":200},{},[201,206],{"type":43,"tag":123,"props":202,"children":203},{},[204],{"type":48,"value":205},"Tests relying on ToString for comparison",{"type":43,"tag":123,"props":207,"children":208},{},[209],{"type":48,"value":210},"Brittle to formatting changes, obscure failure messages",{"type":43,"tag":101,"props":212,"children":213},{},[214,219],{"type":43,"tag":123,"props":215,"children":216},{},[217],{"type":48,"value":218},"Tests with exception handling logic",{"type":43,"tag":123,"props":220,"children":221},{},[222],{"type":48,"value":223},"Swallowed failures, tests that pass when they shouldn't",{"type":43,"tag":81,"props":225,"children":227},{"id":226},"when-to-use",[228],{"type":48,"value":229},"When to Use",{"type":43,"tag":231,"props":232,"children":233},"ul",{},[234,240,245,250,255],{"type":43,"tag":235,"props":236,"children":237},"li",{},[238],{"type":48,"value":239},"User asks for a comprehensive or formal test smell audit",{"type":43,"tag":235,"props":241,"children":242},{},[243],{"type":48,"value":244},"User asks \"are my tests well-written?\" and wants a thorough analysis",{"type":43,"tag":235,"props":246,"children":247},{},[248],{"type":48,"value":249},"User wants a test quality health check with academic rigor",{"type":43,"tag":235,"props":251,"children":252},{},[253],{"type":48,"value":254},"User asks for a review of test design or structure using standard smell categories",{"type":43,"tag":235,"props":256,"children":257},{},[258],{"type":48,"value":259},"User suspects tests are fragile, flaky, or giving false confidence and wants a deep investigation",{"type":43,"tag":81,"props":261,"children":263},{"id":262},"when-not-to-use",[264],{"type":48,"value":265},"When Not to Use",{"type":43,"tag":231,"props":267,"children":268},{},[269,282,295,307,312],{"type":43,"tag":235,"props":270,"children":271},{},[272,274,280],{"type":48,"value":273},"User wants a quick pragmatic test review (use ",{"type":43,"tag":72,"props":275,"children":277},{"className":276},[],[278],{"type":48,"value":279},"test-anti-patterns",{"type":48,"value":281}," — faster, covers the most common issues)",{"type":43,"tag":235,"props":283,"children":284},{},[285,287,293],{"type":48,"value":286},"User wants to evaluate assertion diversity specifically (use ",{"type":43,"tag":72,"props":288,"children":290},{"className":289},[],[291],{"type":48,"value":292},"assertion-quality",{"type":48,"value":294},")",{"type":43,"tag":235,"props":296,"children":297},{},[298,300,306],{"type":48,"value":299},"User wants to find duplicated boilerplate across tests (use ",{"type":43,"tag":72,"props":301,"children":303},{"className":302},[],[304],{"type":48,"value":305},"exp-test-maintainability",{"type":48,"value":294},{"type":43,"tag":235,"props":308,"children":309},{},[310],{"type":48,"value":311},"User wants to write new tests from scratch (help them directly)",{"type":43,"tag":235,"props":313,"children":314},{},[315],{"type":48,"value":316},"User wants to fix a specific failing test (diagnose and fix directly)",{"type":43,"tag":81,"props":318,"children":320},{"id":319},"inputs",[321],{"type":48,"value":322},"Inputs",{"type":43,"tag":93,"props":324,"children":325},{},[326,347],{"type":43,"tag":97,"props":327,"children":328},{},[329],{"type":43,"tag":101,"props":330,"children":331},{},[332,337,342],{"type":43,"tag":105,"props":333,"children":334},{},[335],{"type":48,"value":336},"Input",{"type":43,"tag":105,"props":338,"children":339},{},[340],{"type":48,"value":341},"Required",{"type":43,"tag":105,"props":343,"children":344},{},[345],{"type":48,"value":346},"Description",{"type":43,"tag":116,"props":348,"children":349},{},[350,368],{"type":43,"tag":101,"props":351,"children":352},{},[353,358,363],{"type":43,"tag":123,"props":354,"children":355},{},[356],{"type":48,"value":357},"Test code",{"type":43,"tag":123,"props":359,"children":360},{},[361],{"type":48,"value":362},"Yes",{"type":43,"tag":123,"props":364,"children":365},{},[366],{"type":48,"value":367},"One or more test files or a test project directory to analyze",{"type":43,"tag":101,"props":369,"children":370},{},[371,376,381],{"type":43,"tag":123,"props":372,"children":373},{},[374],{"type":48,"value":375},"Production code",{"type":43,"tag":123,"props":377,"children":378},{},[379],{"type":48,"value":380},"No",{"type":43,"tag":123,"props":382,"children":383},{},[384],{"type":48,"value":385},"The code under test, for context on whether patterns are justified",{"type":43,"tag":81,"props":387,"children":389},{"id":388},"workflow",[390],{"type":48,"value":391},"Workflow",{"type":43,"tag":393,"props":394,"children":396},"h3",{"id":395},"step-1-detect-language-and-load-extension",[397],{"type":48,"value":398},"Step 1: Detect language and load extension",{"type":43,"tag":51,"props":400,"children":401},{},[402,404,409,411,417,419,425,426,432,433,439],{"type":48,"value":403},"Identify the target codebase's language and test framework. Call the ",{"type":43,"tag":72,"props":405,"children":407},{"className":406},[],[408],{"type":48,"value":77},{"type":48,"value":410}," skill and read the matching extension file (e.g., ",{"type":43,"tag":72,"props":412,"children":414},{"className":413},[],[415],{"type":48,"value":416},"extensions\u002Fdotnet.md",{"type":48,"value":418},", ",{"type":43,"tag":72,"props":420,"children":422},{"className":421},[],[423],{"type":48,"value":424},"extensions\u002Fpython.md",{"type":48,"value":418},{"type":43,"tag":72,"props":427,"children":429},{"className":428},[],[430],{"type":48,"value":431},"extensions\u002Ftypescript.md",{"type":48,"value":418},{"type":43,"tag":72,"props":434,"children":436},{"className":435},[],[437],{"type":48,"value":438},"extensions\u002Fgo.md",{"type":48,"value":440},"). The extension file lists the framework-specific test markers, sleep \u002F wait APIs, skip \u002F ignore attributes, mystery-guest indicators, and integration-test markers that the smell detectors below need.",{"type":43,"tag":393,"props":442,"children":444},{"id":443},"step-2-gather-the-test-code",[445],{"type":48,"value":446},"Step 2: Gather the test code",{"type":43,"tag":51,"props":448,"children":449},{},[450],{"type":48,"value":451},"Read all test files the user provides. If the user points to a directory or project, scan for all test files using the markers in the loaded language extension file.",{"type":43,"tag":51,"props":453,"children":454},{},[455,457,464],{"type":48,"value":456},"For a thorough audit, also consult the ",{"type":43,"tag":458,"props":459,"children":461},"a",{"href":460},"references\u002Ftest-smell-catalog.md",[462],{"type":48,"value":463},"extended smell catalog",{"type":48,"value":465}," which covers 9 additional smell types beyond the core 10 below.",{"type":43,"tag":393,"props":467,"children":469},{"id":468},"step-3-scan-for-test-smells",[470],{"type":48,"value":471},"Step 3: Scan for test smells",{"type":43,"tag":51,"props":473,"children":474},{},[475],{"type":48,"value":476},"For each test method and class, check for the following smell categories. Examples reference .NET attributes but the patterns apply across all supported languages — use the loaded language extension file to map each pattern to the framework you are auditing.",{"type":43,"tag":478,"props":479,"children":481},"h4",{"id":480},"smell-1-conditional-test-logic",[482],{"type":48,"value":483},"Smell 1: Conditional Test Logic",{"type":43,"tag":51,"props":485,"children":486},{},[487,489,495,496,502,503,509,511,517,519,525,526,532,533,539],{"type":48,"value":488},"Test methods containing ",{"type":43,"tag":72,"props":490,"children":492},{"className":491},[],[493],{"type":48,"value":494},"if",{"type":48,"value":418},{"type":43,"tag":72,"props":497,"children":499},{"className":498},[],[500],{"type":48,"value":501},"else",{"type":48,"value":418},{"type":43,"tag":72,"props":504,"children":506},{"className":505},[],[507],{"type":48,"value":508},"switch",{"type":48,"value":510},", ternary (",{"type":43,"tag":72,"props":512,"children":514},{"className":513},[],[515],{"type":48,"value":516},"? :",{"type":48,"value":518},"), ",{"type":43,"tag":72,"props":520,"children":522},{"className":521},[],[523],{"type":48,"value":524},"for",{"type":48,"value":418},{"type":43,"tag":72,"props":527,"children":529},{"className":528},[],[530],{"type":48,"value":531},"foreach",{"type":48,"value":418},{"type":43,"tag":72,"props":534,"children":536},{"className":535},[],[537],{"type":48,"value":538},"while",{"type":48,"value":540},", or pattern-match arms that change assertion behavior. Control flow in tests means some paths may never execute, hiding gaps.",{"type":43,"tag":51,"props":542,"children":543},{},[544,549,551,556,558],{"type":43,"tag":64,"props":545,"children":546},{},[547],{"type":48,"value":548},"Severity:",{"type":48,"value":550}," High\n",{"type":43,"tag":64,"props":552,"children":553},{},[554],{"type":48,"value":555},"Detection:",{"type":48,"value":557}," Any control-flow statement inside a test method body that affects which assertions run.\n",{"type":43,"tag":64,"props":559,"children":560},{},[561],{"type":48,"value":562},"Exceptions (per-language idioms, do NOT flag):",{"type":43,"tag":231,"props":564,"children":565},{},[566,584,610,653,691],{"type":43,"tag":235,"props":567,"children":568},{},[569,574,576,582],{"type":43,"tag":64,"props":570,"children":571},{},[572],{"type":48,"value":573},"Foreach-assert",{"type":48,"value":575}," used solely to assert every item in a known collection (the assertion ",{"type":43,"tag":577,"props":578,"children":579},"em",{},[580],{"type":48,"value":581},"is",{"type":48,"value":583}," the loop body).",{"type":43,"tag":235,"props":585,"children":586},{},[587,592,594,600,602,608],{"type":43,"tag":64,"props":588,"children":589},{},[590],{"type":48,"value":591},"Go \u002F Rust table-driven tests",{"type":48,"value":593},": ",{"type":43,"tag":72,"props":595,"children":597},{"className":596},[],[598],{"type":48,"value":599},"for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { ... }) }",{"type":48,"value":601}," (Go) or ",{"type":43,"tag":72,"props":603,"children":605},{"className":604},[],[606],{"type":48,"value":607},"#[rstest]",{"type":48,"value":609}," parametrized loops are idiomatic.",{"type":43,"tag":235,"props":611,"children":612},{},[613,651],{"type":43,"tag":64,"props":614,"children":615},{},[616,622,624,630,631,637,638,644,645],{"type":43,"tag":72,"props":617,"children":619},{"className":618},[],[620],{"type":48,"value":621},"it.each(...)",{"type":48,"value":623}," \u002F ",{"type":43,"tag":72,"props":625,"children":627},{"className":626},[],[628],{"type":48,"value":629},"test.each(...)",{"type":48,"value":623},{"type":43,"tag":72,"props":632,"children":634},{"className":633},[],[635],{"type":48,"value":636},"@pytest.mark.parametrize",{"type":48,"value":623},{"type":43,"tag":72,"props":639,"children":641},{"className":640},[],[642],{"type":48,"value":643},"[Theory] + [InlineData]",{"type":48,"value":623},{"type":43,"tag":72,"props":646,"children":648},{"className":647},[],[649],{"type":48,"value":650},"@ParameterizedTest",{"type":48,"value":652}," parametrization driven by data tables.",{"type":43,"tag":235,"props":654,"children":655},{},[656,674,676,689],{"type":43,"tag":64,"props":657,"children":658},{},[659,661,667,668],{"type":48,"value":660},"Pester ",{"type":43,"tag":72,"props":662,"children":664},{"className":663},[],[665],{"type":48,"value":666},"-ForEach",{"type":48,"value":623},{"type":43,"tag":72,"props":669,"children":671},{"className":670},[],[672],{"type":48,"value":673},"-TestCases",{"type":48,"value":675}," and ",{"type":43,"tag":64,"props":677,"children":678},{},[679,681,687],{"type":48,"value":680},"RSpec ",{"type":43,"tag":72,"props":682,"children":684},{"className":683},[],[685],{"type":48,"value":686},"where",{"type":48,"value":688}," blocks",{"type":48,"value":690},".",{"type":43,"tag":235,"props":692,"children":693},{},[694,713,714,725,726,737],{"type":43,"tag":64,"props":695,"children":696},{},[697,699,705,707],{"type":48,"value":698},"Catch2 ",{"type":43,"tag":72,"props":700,"children":702},{"className":701},[],[703],{"type":48,"value":704},"SECTION",{"type":48,"value":706},"s and ",{"type":43,"tag":72,"props":708,"children":710},{"className":709},[],[711],{"type":48,"value":712},"GENERATE(...)",{"type":48,"value":418},{"type":43,"tag":64,"props":715,"children":716},{},[717,719],{"type":48,"value":718},"doctest ",{"type":43,"tag":72,"props":720,"children":722},{"className":721},[],[723],{"type":48,"value":724},"SUBCASE",{"type":48,"value":418},{"type":43,"tag":64,"props":727,"children":728},{},[729,731],{"type":48,"value":730},"GoogleTest ",{"type":43,"tag":72,"props":732,"children":734},{"className":733},[],[735],{"type":48,"value":736},"INSTANTIATE_TEST_SUITE_P",{"type":48,"value":690},{"type":43,"tag":478,"props":739,"children":741},{"id":740},"smell-2-mystery-guest",[742],{"type":48,"value":743},"Smell 2: Mystery Guest",{"type":43,"tag":51,"props":745,"children":746},{},[747],{"type":48,"value":748},"Tests that depend on external resources — files on disk, databases, network endpoints, environment variables — without making the dependency explicit or using test doubles.",{"type":43,"tag":51,"props":750,"children":751},{},[752,756,757,761,763,769,770,776,777,783,784,790,792,798,799,805,806,812,813,819,821,827,828,834,835,841,843,849,850,856,857,863,864,870,872,878,879,885,886,892,894,900,901,907,908,914,916,922,923,929,930,936,938,944,945,951,952,958,960,966,967,973,974,979,981,987,988,994,995,1001,1003,1009,1010,1016,1017,1023,1025,1030],{"type":43,"tag":64,"props":753,"children":754},{},[755],{"type":48,"value":548},{"type":48,"value":550},{"type":43,"tag":64,"props":758,"children":759},{},[760],{"type":48,"value":555},{"type":48,"value":762}," Test methods that read files, open database connections, make HTTP requests (without a test handler), read environment variables, or use hard-coded file paths. Per language: ",{"type":43,"tag":72,"props":764,"children":766},{"className":765},[],[767],{"type":48,"value":768},"File.ReadAllText",{"type":48,"value":623},{"type":43,"tag":72,"props":771,"children":773},{"className":772},[],[774],{"type":48,"value":775},"Directory.GetFiles",{"type":48,"value":623},{"type":43,"tag":72,"props":778,"children":780},{"className":779},[],[781],{"type":48,"value":782},"HttpClient",{"type":48,"value":623},{"type":43,"tag":72,"props":785,"children":787},{"className":786},[],[788],{"type":48,"value":789},"Environment.GetEnvironmentVariable",{"type":48,"value":791}," (.NET); ",{"type":43,"tag":72,"props":793,"children":795},{"className":794},[],[796],{"type":48,"value":797},"open()",{"type":48,"value":623},{"type":43,"tag":72,"props":800,"children":802},{"className":801},[],[803],{"type":48,"value":804},"pathlib.Path.read_text()",{"type":48,"value":623},{"type":43,"tag":72,"props":807,"children":809},{"className":808},[],[810],{"type":48,"value":811},"requests.get()",{"type":48,"value":623},{"type":43,"tag":72,"props":814,"children":816},{"className":815},[],[817],{"type":48,"value":818},"os.environ[...]",{"type":48,"value":820}," (Python); ",{"type":43,"tag":72,"props":822,"children":824},{"className":823},[],[825],{"type":48,"value":826},"fs.readFileSync",{"type":48,"value":623},{"type":43,"tag":72,"props":829,"children":831},{"className":830},[],[832],{"type":48,"value":833},"fetch(...)",{"type":48,"value":623},{"type":43,"tag":72,"props":836,"children":838},{"className":837},[],[839],{"type":48,"value":840},"process.env.X",{"type":48,"value":842}," (JS\u002FTS); ",{"type":43,"tag":72,"props":844,"children":846},{"className":845},[],[847],{"type":48,"value":848},"Files.readAllBytes",{"type":48,"value":623},{"type":43,"tag":72,"props":851,"children":853},{"className":852},[],[854],{"type":48,"value":855},"Files.newInputStream",{"type":48,"value":623},{"type":43,"tag":72,"props":858,"children":860},{"className":859},[],[861],{"type":48,"value":862},"HttpClient.send",{"type":48,"value":623},{"type":43,"tag":72,"props":865,"children":867},{"className":866},[],[868],{"type":48,"value":869},"System.getenv",{"type":48,"value":871}," (Java); ",{"type":43,"tag":72,"props":873,"children":875},{"className":874},[],[876],{"type":48,"value":877},"os.ReadFile",{"type":48,"value":623},{"type":43,"tag":72,"props":880,"children":882},{"className":881},[],[883],{"type":48,"value":884},"http.Get",{"type":48,"value":623},{"type":43,"tag":72,"props":887,"children":889},{"className":888},[],[890],{"type":48,"value":891},"os.Getenv",{"type":48,"value":893}," (Go); ",{"type":43,"tag":72,"props":895,"children":897},{"className":896},[],[898],{"type":48,"value":899},"File.read",{"type":48,"value":623},{"type":43,"tag":72,"props":902,"children":904},{"className":903},[],[905],{"type":48,"value":906},"Net::HTTP.get",{"type":48,"value":623},{"type":43,"tag":72,"props":909,"children":911},{"className":910},[],[912],{"type":48,"value":913},"ENV[...]",{"type":48,"value":915}," (Ruby); ",{"type":43,"tag":72,"props":917,"children":919},{"className":918},[],[920],{"type":48,"value":921},"std::fs::read_to_string",{"type":48,"value":623},{"type":43,"tag":72,"props":924,"children":926},{"className":925},[],[927],{"type":48,"value":928},"reqwest::get",{"type":48,"value":623},{"type":43,"tag":72,"props":931,"children":933},{"className":932},[],[934],{"type":48,"value":935},"std::env::var",{"type":48,"value":937}," (Rust); ",{"type":43,"tag":72,"props":939,"children":941},{"className":940},[],[942],{"type":48,"value":943},"String(contentsOfFile:)",{"type":48,"value":623},{"type":43,"tag":72,"props":946,"children":948},{"className":947},[],[949],{"type":48,"value":950},"URLSession.shared.data",{"type":48,"value":623},{"type":43,"tag":72,"props":953,"children":955},{"className":954},[],[956],{"type":48,"value":957},"ProcessInfo.processInfo.environment",{"type":48,"value":959}," (Swift); ",{"type":43,"tag":72,"props":961,"children":963},{"className":962},[],[964],{"type":48,"value":965},"File(...).readText()",{"type":48,"value":623},{"type":43,"tag":72,"props":968,"children":970},{"className":969},[],[971],{"type":48,"value":972},"URL(...).openConnection()",{"type":48,"value":623},{"type":43,"tag":72,"props":975,"children":977},{"className":976},[],[978],{"type":48,"value":869},{"type":48,"value":980}," (Kotlin); ",{"type":43,"tag":72,"props":982,"children":984},{"className":983},[],[985],{"type":48,"value":986},"Get-Content",{"type":48,"value":623},{"type":43,"tag":72,"props":989,"children":991},{"className":990},[],[992],{"type":48,"value":993},"Invoke-WebRequest",{"type":48,"value":623},{"type":43,"tag":72,"props":996,"children":998},{"className":997},[],[999],{"type":48,"value":1000},"$env:X",{"type":48,"value":1002}," (Pester); ",{"type":43,"tag":72,"props":1004,"children":1006},{"className":1005},[],[1007],{"type":48,"value":1008},"std::ifstream",{"type":48,"value":623},{"type":43,"tag":72,"props":1011,"children":1013},{"className":1012},[],[1014],{"type":48,"value":1015},"curl_easy_perform",{"type":48,"value":623},{"type":43,"tag":72,"props":1018,"children":1020},{"className":1019},[],[1021],{"type":48,"value":1022},"std::getenv",{"type":48,"value":1024}," (C++).\n",{"type":43,"tag":64,"props":1026,"children":1027},{},[1028],{"type":48,"value":1029},"Exception:",{"type":48,"value":1031}," In-memory fakes, test-specific handlers, or hermetic test data factories are fine.",{"type":43,"tag":478,"props":1033,"children":1035},{"id":1034},"smell-3-sleepy-test",[1036],{"type":48,"value":1037},"Smell 3: Sleepy Test",{"type":43,"tag":51,"props":1039,"children":1040},{},[1041],{"type":48,"value":1042},"Tests that call sleep or delay functions to wait for a condition. These introduce non-deterministic timing and slow down the suite.",{"type":43,"tag":51,"props":1044,"children":1045},{},[1046,1050,1051,1056,1058,1063,1065,1069,1071,1077,1078,1084,1085,1091,1092,1098,1099,1105,1106,1112,1113,1119,1121,1127,1128,1134,1135,1141,1142,1148,1149,1155,1156,1162,1163,1169,1170,1175,1176,1182,1184,1190,1191,1197,1198,1204,1205,1211],{"type":43,"tag":64,"props":1047,"children":1048},{},[1049],{"type":48,"value":548},{"type":48,"value":550},{"type":43,"tag":64,"props":1052,"children":1053},{},[1054],{"type":48,"value":1055},"Calibration:",{"type":48,"value":1057}," Severity does ",{"type":43,"tag":64,"props":1059,"children":1060},{},[1061],{"type":48,"value":1062},"not",{"type":48,"value":1064}," drop because the test is an integration test — a fixed sleep is still flaky and slow there. Report it as High and recommend polling\u002Fawaiting the condition with a timeout.\n",{"type":43,"tag":64,"props":1066,"children":1067},{},[1068],{"type":48,"value":555},{"type":48,"value":1070}," Calls to sleep\u002Fdelay functions inside test methods: ",{"type":43,"tag":72,"props":1072,"children":1074},{"className":1073},[],[1075],{"type":48,"value":1076},"Thread.Sleep",{"type":48,"value":623},{"type":43,"tag":72,"props":1079,"children":1081},{"className":1080},[],[1082],{"type":48,"value":1083},"Task.Delay",{"type":48,"value":791},{"type":43,"tag":72,"props":1086,"children":1088},{"className":1087},[],[1089],{"type":48,"value":1090},"time.sleep",{"type":48,"value":623},{"type":43,"tag":72,"props":1093,"children":1095},{"className":1094},[],[1096],{"type":48,"value":1097},"asyncio.sleep",{"type":48,"value":820},{"type":43,"tag":72,"props":1100,"children":1102},{"className":1101},[],[1103],{"type":48,"value":1104},"setTimeout",{"type":48,"value":623},{"type":43,"tag":72,"props":1107,"children":1109},{"className":1108},[],[1110],{"type":48,"value":1111},"await new Promise(r => setTimeout(...))",{"type":48,"value":623},{"type":43,"tag":72,"props":1114,"children":1116},{"className":1115},[],[1117],{"type":48,"value":1118},"jest.advanceTimersByTime",{"type":48,"value":1120}," not paired with a wait (JS\u002FTS); ",{"type":43,"tag":72,"props":1122,"children":1124},{"className":1123},[],[1125],{"type":48,"value":1126},"Thread.sleep",{"type":48,"value":623},{"type":43,"tag":72,"props":1129,"children":1131},{"className":1130},[],[1132],{"type":48,"value":1133},"TimeUnit.SECONDS.sleep",{"type":48,"value":871},{"type":43,"tag":72,"props":1136,"children":1138},{"className":1137},[],[1139],{"type":48,"value":1140},"time.Sleep",{"type":48,"value":893},{"type":43,"tag":72,"props":1143,"children":1145},{"className":1144},[],[1146],{"type":48,"value":1147},"sleep",{"type":48,"value":623},{"type":43,"tag":72,"props":1150,"children":1152},{"className":1151},[],[1153],{"type":48,"value":1154},"Kernel#sleep",{"type":48,"value":915},{"type":43,"tag":72,"props":1157,"children":1159},{"className":1158},[],[1160],{"type":48,"value":1161},"std::thread::sleep",{"type":48,"value":623},{"type":43,"tag":72,"props":1164,"children":1166},{"className":1165},[],[1167],{"type":48,"value":1168},"tokio::time::sleep",{"type":48,"value":937},{"type":43,"tag":72,"props":1171,"children":1173},{"className":1172},[],[1174],{"type":48,"value":1126},{"type":48,"value":623},{"type":43,"tag":72,"props":1177,"children":1179},{"className":1178},[],[1180],{"type":48,"value":1181},"delay",{"type":48,"value":1183}," (Kotlin coroutines); ",{"type":43,"tag":72,"props":1185,"children":1187},{"className":1186},[],[1188],{"type":48,"value":1189},"sleep(_:)",{"type":48,"value":623},{"type":43,"tag":72,"props":1192,"children":1194},{"className":1193},[],[1195],{"type":48,"value":1196},"Task.sleep",{"type":48,"value":959},{"type":43,"tag":72,"props":1199,"children":1201},{"className":1200},[],[1202],{"type":48,"value":1203},"Start-Sleep",{"type":48,"value":1002},{"type":43,"tag":72,"props":1206,"children":1208},{"className":1207},[],[1209],{"type":48,"value":1210},"std::this_thread::sleep_for",{"type":48,"value":1212}," (C++). See the matching language extension file for the full list.",{"type":43,"tag":478,"props":1214,"children":1216},{"id":1215},"smell-4-assertion-free-test-unknown-test",[1217],{"type":48,"value":1218},"Smell 4: Assertion-Free Test (Unknown Test)",{"type":43,"tag":51,"props":1220,"children":1221},{},[1222],{"type":48,"value":1223},"Tests that execute code but never assert anything. Test frameworks report these as passing even if the code is completely broken, as long as no exception is thrown.",{"type":43,"tag":51,"props":1225,"children":1226},{},[1227,1231,1232,1236,1238,1244,1246,1252,1253,1259,1261,1267,1269,1275,1277,1283,1284,1290,1292,1298,1299,1305,1306,1311,1313,1319,1321,1327,1328,1334,1336,1341,1342,1348,1350,1356,1357,1363,1364,1370,1372,1378,1379,1385,1387,1392,1393,1399,1401,1407,1409,1415,1416,1422,1423,1429,1430,1436,1437],{"type":43,"tag":64,"props":1228,"children":1229},{},[1230],{"type":48,"value":548},{"type":48,"value":550},{"type":43,"tag":64,"props":1233,"children":1234},{},[1235],{"type":48,"value":555},{"type":48,"value":1237}," A test method with no assertion calls and no expected-exception annotation. Framework-specific: missing ",{"type":43,"tag":72,"props":1239,"children":1241},{"className":1240},[],[1242],{"type":48,"value":1243},"Assert.*",{"type":48,"value":1245}," (.NET); no ",{"type":43,"tag":72,"props":1247,"children":1249},{"className":1248},[],[1250],{"type":48,"value":1251},"assert",{"type":48,"value":623},{"type":43,"tag":72,"props":1254,"children":1256},{"className":1255},[],[1257],{"type":48,"value":1258},"pytest.raises",{"type":48,"value":1260}," (Python); no ",{"type":43,"tag":72,"props":1262,"children":1264},{"className":1263},[],[1265],{"type":48,"value":1266},"expect(...)",{"type":48,"value":1268}," or ",{"type":43,"tag":72,"props":1270,"children":1272},{"className":1271},[],[1273],{"type":48,"value":1274},"assert.*",{"type":48,"value":1276}," (JS\u002FTS); no ",{"type":43,"tag":72,"props":1278,"children":1280},{"className":1279},[],[1281],{"type":48,"value":1282},"assert*",{"type":48,"value":623},{"type":43,"tag":72,"props":1285,"children":1287},{"className":1286},[],[1288],{"type":48,"value":1289},"assertThat",{"type":48,"value":1291}," (Java); no ",{"type":43,"tag":72,"props":1293,"children":1295},{"className":1294},[],[1296],{"type":48,"value":1297},"t.Error*",{"type":48,"value":623},{"type":43,"tag":72,"props":1300,"children":1302},{"className":1301},[],[1303],{"type":48,"value":1304},"t.Fatal*",{"type":48,"value":623},{"type":43,"tag":72,"props":1307,"children":1309},{"className":1308},[],[1310],{"type":48,"value":1274},{"type":48,"value":1312}," testify (Go); no ",{"type":43,"tag":72,"props":1314,"children":1316},{"className":1315},[],[1317],{"type":48,"value":1318},"expect",{"type":48,"value":1320},"\u002F",{"type":43,"tag":72,"props":1322,"children":1324},{"className":1323},[],[1325],{"type":48,"value":1326},".to",{"type":48,"value":1320},{"type":43,"tag":72,"props":1329,"children":1331},{"className":1330},[],[1332],{"type":48,"value":1333},".eq",{"type":48,"value":1335}," (RSpec) or ",{"type":43,"tag":72,"props":1337,"children":1339},{"className":1338},[],[1340],{"type":48,"value":1282},{"type":48,"value":1320},{"type":43,"tag":72,"props":1343,"children":1345},{"className":1344},[],[1346],{"type":48,"value":1347},"refute*",{"type":48,"value":1349}," (Minitest); no ",{"type":43,"tag":72,"props":1351,"children":1353},{"className":1352},[],[1354],{"type":48,"value":1355},"assert*!",{"type":48,"value":623},{"type":43,"tag":72,"props":1358,"children":1360},{"className":1359},[],[1361],{"type":48,"value":1362},"assert_eq!",{"type":48,"value":623},{"type":43,"tag":72,"props":1365,"children":1367},{"className":1366},[],[1368],{"type":48,"value":1369},"panic!",{"type":48,"value":1371}," (Rust); no ",{"type":43,"tag":72,"props":1373,"children":1375},{"className":1374},[],[1376],{"type":48,"value":1377},"XCTAssert*",{"type":48,"value":623},{"type":43,"tag":72,"props":1380,"children":1382},{"className":1381},[],[1383],{"type":48,"value":1384},"#expect",{"type":48,"value":1386}," (Swift); no ",{"type":43,"tag":72,"props":1388,"children":1390},{"className":1389},[],[1391],{"type":48,"value":1282},{"type":48,"value":623},{"type":43,"tag":72,"props":1394,"children":1396},{"className":1395},[],[1397],{"type":48,"value":1398},"should*",{"type":48,"value":1400}," \u002F Kotest matchers (Kotlin); no ",{"type":43,"tag":72,"props":1402,"children":1404},{"className":1403},[],[1405],{"type":48,"value":1406},"Should -*",{"type":48,"value":1408}," (Pester); no ",{"type":43,"tag":72,"props":1410,"children":1412},{"className":1411},[],[1413],{"type":48,"value":1414},"EXPECT_*",{"type":48,"value":623},{"type":43,"tag":72,"props":1417,"children":1419},{"className":1418},[],[1420],{"type":48,"value":1421},"ASSERT_*",{"type":48,"value":623},{"type":43,"tag":72,"props":1424,"children":1426},{"className":1425},[],[1427],{"type":48,"value":1428},"REQUIRE",{"type":48,"value":623},{"type":43,"tag":72,"props":1431,"children":1433},{"className":1432},[],[1434],{"type":48,"value":1435},"CHECK",{"type":48,"value":1024},{"type":43,"tag":64,"props":1438,"children":1439},{},[1440],{"type":48,"value":1055},{"type":43,"tag":231,"props":1442,"children":1443},{},[1444,1471,1528,1561,1600],{"type":43,"tag":235,"props":1445,"children":1446},{},[1447,1449,1455,1456,1462,1463,1469],{"type":48,"value":1448},"A method named ",{"type":43,"tag":72,"props":1450,"children":1452},{"className":1451},[],[1453],{"type":48,"value":1454},"*_DoesNotThrow",{"type":48,"value":623},{"type":43,"tag":72,"props":1457,"children":1459},{"className":1458},[],[1460],{"type":48,"value":1461},"*_no_exception",{"type":48,"value":623},{"type":43,"tag":72,"props":1464,"children":1466},{"className":1465},[],[1467],{"type":48,"value":1468},"should not throw",{"type":48,"value":1470}," is implicitly asserting no exception — still flag it but note it may be intentional.",{"type":43,"tag":235,"props":1472,"children":1473},{},[1474,1479,1480,1486,1488,1494,1496,1502,1504,1510,1512,1518,1520,1526],{"type":43,"tag":64,"props":1475,"children":1476},{},[1477],{"type":48,"value":1478},"Mock-call verifications count as assertions",{"type":48,"value":593},{"type":43,"tag":72,"props":1481,"children":1483},{"className":1482},[],[1484],{"type":48,"value":1485},"mock.Verify(...)",{"type":48,"value":1487}," (Moq), ",{"type":43,"tag":72,"props":1489,"children":1491},{"className":1490},[],[1492],{"type":48,"value":1493},"Mock.AssertWasCalled",{"type":48,"value":1495}," (NSubstitute), ",{"type":43,"tag":72,"props":1497,"children":1499},{"className":1498},[],[1500],{"type":48,"value":1501},"mock.assert_called_with(...)",{"type":48,"value":1503}," (Python), ",{"type":43,"tag":72,"props":1505,"children":1507},{"className":1506},[],[1508],{"type":48,"value":1509},"expect(mock).toHaveBeenCalledWith(...)",{"type":48,"value":1511}," (Jest), ",{"type":43,"tag":72,"props":1513,"children":1515},{"className":1514},[],[1516],{"type":48,"value":1517},"verify(mock).method(...)",{"type":48,"value":1519}," (Mockito), ",{"type":43,"tag":72,"props":1521,"children":1523},{"className":1522},[],[1524],{"type":48,"value":1525},"Should -Invoke",{"type":48,"value":1527}," (Pester) — do NOT flag tests using these as assertion-free.",{"type":43,"tag":235,"props":1529,"children":1530},{},[1531,1536,1537,1543,1545,1551,1553,1559],{"type":43,"tag":64,"props":1532,"children":1533},{},[1534],{"type":48,"value":1535},"Bare assertion forms count",{"type":48,"value":593},{"type":43,"tag":72,"props":1538,"children":1540},{"className":1539},[],[1541],{"type":48,"value":1542},"assert x == y",{"type":48,"value":1544}," (pytest), ",{"type":43,"tag":72,"props":1546,"children":1548},{"className":1547},[],[1549],{"type":48,"value":1550},"if got != want { t.Errorf(...) }",{"type":48,"value":1552}," (Go), ",{"type":43,"tag":72,"props":1554,"children":1556},{"className":1555},[],[1557],{"type":48,"value":1558},"assert!(cond)",{"type":48,"value":1560}," (Rust) are canonical.",{"type":43,"tag":235,"props":1562,"children":1563},{},[1564,1569,1570,1576,1577,1583,1584,1590,1592,1598],{"type":43,"tag":64,"props":1565,"children":1566},{},[1567],{"type":48,"value":1568},"Snapshot assertions count",{"type":48,"value":593},{"type":43,"tag":72,"props":1571,"children":1573},{"className":1572},[],[1574],{"type":48,"value":1575},".toMatchSnapshot()",{"type":48,"value":1511},{"type":43,"tag":72,"props":1578,"children":1580},{"className":1579},[],[1581],{"type":48,"value":1582},"syrupy",{"type":48,"value":1544},{"type":43,"tag":72,"props":1585,"children":1587},{"className":1586},[],[1588],{"type":48,"value":1589},"SnapshotTesting",{"type":48,"value":1591}," (Swift), ",{"type":43,"tag":72,"props":1593,"children":1595},{"className":1594},[],[1596],{"type":48,"value":1597},"approval-tests",{"type":48,"value":1599}," are real assertions.",{"type":43,"tag":235,"props":1601,"children":1602},{},[1603,1608,1609,1615,1617,1623,1624,1630,1632,1638,1640,1646,1648,1654,1656,1661],{"type":43,"tag":64,"props":1604,"children":1605},{},[1606],{"type":48,"value":1607},"Missing await on async assertions is its own critical smell",{"type":48,"value":593},{"type":43,"tag":72,"props":1610,"children":1612},{"className":1611},[],[1613],{"type":48,"value":1614},"expect(promise).resolves.toBe(x)",{"type":48,"value":1616}," without ",{"type":43,"tag":72,"props":1618,"children":1620},{"className":1619},[],[1621],{"type":48,"value":1622},"await",{"type":48,"value":1320},{"type":43,"tag":72,"props":1625,"children":1627},{"className":1626},[],[1628],{"type":48,"value":1629},"return",{"type":48,"value":1631}," (Jest), un-awaited ",{"type":43,"tag":72,"props":1633,"children":1635},{"className":1634},[],[1636],{"type":48,"value":1637},"Assert.ThrowsAsync",{"type":48,"value":1639}," (xUnit), un-awaited coroutines in ",{"type":43,"tag":72,"props":1641,"children":1643},{"className":1642},[],[1644],{"type":48,"value":1645},"pytest-asyncio",{"type":48,"value":1647},", Kotest tests without ",{"type":43,"tag":72,"props":1649,"children":1651},{"className":1650},[],[1652],{"type":48,"value":1653},"runTest",{"type":48,"value":1655},", Swift Testing async cases without ",{"type":43,"tag":72,"props":1657,"children":1659},{"className":1658},[],[1660],{"type":48,"value":1622},{"type":48,"value":1662},". These tests have assertion calls but silently pass — flag with a dedicated note.",{"type":43,"tag":478,"props":1664,"children":1666},{"id":1665},"smell-5-eager-test",[1667],{"type":48,"value":1668},"Smell 5: Eager Test",{"type":43,"tag":51,"props":1670,"children":1671},{},[1672],{"type":48,"value":1673},"A test method that calls many different production methods, making it unclear what behavior is being tested. When it fails, diagnosis is difficult because the failure could stem from any of the calls.",{"type":43,"tag":51,"props":1675,"children":1676},{},[1677,1681,1683,1687,1689,1693,1695,1701,1702,1708,1709,1715,1716,1722,1723,1729],{"type":43,"tag":64,"props":1678,"children":1679},{},[1680],{"type":48,"value":548},{"type":48,"value":1682}," Medium\n",{"type":43,"tag":64,"props":1684,"children":1685},{},[1686],{"type":48,"value":555},{"type":48,"value":1688}," A test method that calls 4+ distinct methods on the production object (excluding setup\u002Fconstruction). Count unique method names, not call count.\n",{"type":43,"tag":64,"props":1690,"children":1691},{},[1692],{"type":48,"value":1055},{"type":48,"value":1694}," Integration \u002F end-to-end \u002F workflow tests may legitimately call multiple methods. Check for integration markers in the loaded language extension file (e.g., ",{"type":43,"tag":72,"props":1696,"children":1698},{"className":1697},[],[1699],{"type":48,"value":1700},"[Trait(\"Category\", \"Integration\")]",{"type":48,"value":418},{"type":43,"tag":72,"props":1703,"children":1705},{"className":1704},[],[1706],{"type":48,"value":1707},"@Tag(\"integration\")",{"type":48,"value":418},{"type":43,"tag":72,"props":1710,"children":1712},{"className":1711},[],[1713],{"type":48,"value":1714},"pytest.mark.integration",{"type":48,"value":418},{"type":43,"tag":72,"props":1717,"children":1719},{"className":1718},[],[1720],{"type":48,"value":1721},"*_integration_test.go",{"type":48,"value":418},{"type":43,"tag":72,"props":1724,"children":1726},{"className":1725},[],[1727],{"type":48,"value":1728},"Describe ... -Tag 'Integration'",{"type":48,"value":1730},") and downgrade.",{"type":43,"tag":478,"props":1732,"children":1734},{"id":1733},"smell-6-magic-number-test",[1735],{"type":48,"value":1736},"Smell 6: Magic Number Test",{"type":43,"tag":51,"props":1738,"children":1739},{},[1740,1742,1748,1749,1755,1756,1762],{"type":48,"value":1741},"Assertions that contain unexplained numeric literals. The intent of ",{"type":43,"tag":72,"props":1743,"children":1745},{"className":1744},[],[1746],{"type":48,"value":1747},"Assert.AreEqual(42, result)",{"type":48,"value":623},{"type":43,"tag":72,"props":1750,"children":1752},{"className":1751},[],[1753],{"type":48,"value":1754},"assert result == 42",{"type":48,"value":623},{"type":43,"tag":72,"props":1757,"children":1759},{"className":1758},[],[1760],{"type":48,"value":1761},"expect(result).toBe(42)",{"type":48,"value":1763}," is unclear without context — what does 42 represent?",{"type":43,"tag":51,"props":1765,"children":1766},{},[1767,1771,1772,1776,1778,1784,1786,1790,1792,1798,1799,1805,1806,1812],{"type":43,"tag":64,"props":1768,"children":1769},{},[1770],{"type":48,"value":548},{"type":48,"value":1682},{"type":43,"tag":64,"props":1773,"children":1774},{},[1775],{"type":48,"value":555},{"type":48,"value":1777}," Numeric literals (other than 0, 1, -1, and the literal used in the test name) appearing as ",{"type":43,"tag":72,"props":1779,"children":1781},{"className":1780},[],[1782],{"type":48,"value":1783},"expected",{"type":48,"value":1785}," parameters in assertion methods or comparison operands.\n",{"type":43,"tag":64,"props":1787,"children":1788},{},[1789],{"type":48,"value":1055},{"type":48,"value":1791}," Small integers in context (like count checks ",{"type":43,"tag":72,"props":1793,"children":1795},{"className":1794},[],[1796],{"type":48,"value":1797},"Assert.AreEqual(3, list.Count)",{"type":48,"value":623},{"type":43,"tag":72,"props":1800,"children":1802},{"className":1801},[],[1803],{"type":48,"value":1804},"assert len(items) == 3",{"type":48,"value":623},{"type":43,"tag":72,"props":1807,"children":1809},{"className":1808},[],[1810],{"type":48,"value":1811},"expect(arr.length).toBe(3)",{"type":48,"value":1813}," where 3 items were just added) are acceptable — only flag when the number's meaning is genuinely unclear.",{"type":43,"tag":478,"props":1815,"children":1817},{"id":1816},"smell-7-sensitive-equality",[1818],{"type":48,"value":1819},"Smell 7: Sensitive Equality",{"type":43,"tag":51,"props":1821,"children":1822},{},[1823],{"type":48,"value":1824},"Tests that use string conversion for comparison or assertion. If the underlying string representation changes, the test breaks even though the actual behavior is correct.",{"type":43,"tag":51,"props":1826,"children":1827},{},[1828,1832,1833,1837,1839,1845,1846,1852,1853,1859,1860,1866,1867,1873,1875,1881,1882,1888,1889,1895,1896,1902,1904,1910,1912,1918,1919,1925,1926,1932,1934,1940,1941,1947,1949,1955,1956,1962],{"type":43,"tag":64,"props":1829,"children":1830},{},[1831],{"type":48,"value":548},{"type":48,"value":1682},{"type":43,"tag":64,"props":1834,"children":1835},{},[1836],{"type":48,"value":555},{"type":48,"value":1838}," ",{"type":43,"tag":72,"props":1840,"children":1842},{"className":1841},[],[1843],{"type":48,"value":1844},"Assert.AreEqual(expected, obj.ToString())",{"type":48,"value":791},{"type":43,"tag":72,"props":1847,"children":1849},{"className":1848},[],[1850],{"type":48,"value":1851},"assert str(obj) == \"...\"",{"type":48,"value":1268},{"type":43,"tag":72,"props":1854,"children":1856},{"className":1855},[],[1857],{"type":48,"value":1858},"assert repr(obj) == \"...\"",{"type":48,"value":820},{"type":43,"tag":72,"props":1861,"children":1863},{"className":1862},[],[1864],{"type":48,"value":1865},"expect(obj.toString()).toBe(\"...\")",{"type":48,"value":1268},{"type":43,"tag":72,"props":1868,"children":1870},{"className":1869},[],[1871],{"type":48,"value":1872},"expect(",{"type":48,"value":1874},"${obj}",{"type":43,"tag":72,"props":1876,"children":1878},{"className":1877},[],[1879],{"type":48,"value":1880},").toBe(...)",{"type":48,"value":842},{"type":43,"tag":72,"props":1883,"children":1885},{"className":1884},[],[1886],{"type":48,"value":1887},"assertEquals(expected, obj.toString())",{"type":48,"value":871},{"type":43,"tag":72,"props":1890,"children":1892},{"className":1891},[],[1893],{"type":48,"value":1894},"assert.Equal(t, \"...\", fmt.Sprint(obj))",{"type":48,"value":1268},{"type":43,"tag":72,"props":1897,"children":1899},{"className":1898},[],[1900],{"type":48,"value":1901},"obj.String()",{"type":48,"value":1903}," chains (Go); ",{"type":43,"tag":72,"props":1905,"children":1907},{"className":1906},[],[1908],{"type":48,"value":1909},"expect(obj.to_s).to eq(\"...\")",{"type":48,"value":1911}," (RSpec); ",{"type":43,"tag":72,"props":1913,"children":1915},{"className":1914},[],[1916],{"type":48,"value":1917},"assert_eq!(format!(\"{}\", obj), \"...\")",{"type":48,"value":1268},{"type":43,"tag":72,"props":1920,"children":1922},{"className":1921},[],[1923],{"type":48,"value":1924},"assert_eq!(format!(\"{:?}\", obj), \"...\")",{"type":48,"value":937},{"type":43,"tag":72,"props":1927,"children":1929},{"className":1928},[],[1930],{"type":48,"value":1931},"XCTAssertEqual(obj.description, \"...\")",{"type":48,"value":1933}," or string-interpolation assertion (Swift); ",{"type":43,"tag":72,"props":1935,"children":1937},{"className":1936},[],[1938],{"type":48,"value":1939},"assertEquals(\"...\", obj.toString())",{"type":48,"value":980},{"type":43,"tag":72,"props":1942,"children":1944},{"className":1943},[],[1945],{"type":48,"value":1946},"Should -Be \"...\"",{"type":48,"value":1948}," against a ",{"type":43,"tag":72,"props":1950,"children":1952},{"className":1951},[],[1953],{"type":48,"value":1954},"[string]$obj",{"type":48,"value":1002},{"type":43,"tag":72,"props":1957,"children":1959},{"className":1958},[],[1960],{"type":48,"value":1961},"EXPECT_EQ(\"...\", std::to_string(obj))",{"type":48,"value":1963}," (C++).",{"type":43,"tag":478,"props":1965,"children":1967},{"id":1966},"smell-8-exception-handling-in-tests",[1968],{"type":48,"value":1969},"Smell 8: Exception Handling in Tests",{"type":43,"tag":51,"props":1971,"children":1972},{},[1973,1975,1981,1982,1988,1989,1995,1996,2002,2004,2010,2011,2017,2018,2024,2025,2031],{"type":48,"value":1974},"Tests that contain ",{"type":43,"tag":72,"props":1976,"children":1978},{"className":1977},[],[1979],{"type":48,"value":1980},"try",{"type":48,"value":1320},{"type":43,"tag":72,"props":1983,"children":1985},{"className":1984},[],[1986],{"type":48,"value":1987},"catch",{"type":48,"value":1320},{"type":43,"tag":72,"props":1990,"children":1992},{"className":1991},[],[1993],{"type":48,"value":1994},"except",{"type":48,"value":1320},{"type":43,"tag":72,"props":1997,"children":1999},{"className":1998},[],[2000],{"type":48,"value":2001},"rescue",{"type":48,"value":2003}," blocks or ",{"type":43,"tag":72,"props":2005,"children":2007},{"className":2006},[],[2008],{"type":48,"value":2009},"throw",{"type":48,"value":1320},{"type":43,"tag":72,"props":2012,"children":2014},{"className":2013},[],[2015],{"type":48,"value":2016},"raise",{"type":48,"value":1320},{"type":43,"tag":72,"props":2019,"children":2021},{"className":2020},[],[2022],{"type":48,"value":2023},"panic",{"type":48,"value":1320},{"type":43,"tag":72,"props":2026,"children":2028},{"className":2027},[],[2029],{"type":48,"value":2030},"return err",{"type":48,"value":2032}," statements used to manage exception flow instead of asserting on it. This typically means the test is manually managing errors rather than using the framework's built-in exception assertion facilities.",{"type":43,"tag":51,"props":2034,"children":2035},{},[2036,2040,2041,2045,2046,2051,2052,2057,2059,2064,2065,2070,2071,2077,2078,2083,2084,2090,2092,2098,2100,2104,2105,2110,2111,2116,2117,2122],{"type":43,"tag":64,"props":2037,"children":2038},{},[2039],{"type":48,"value":548},{"type":48,"value":1682},{"type":43,"tag":64,"props":2042,"children":2043},{},[2044],{"type":48,"value":555},{"type":48,"value":1838},{"type":43,"tag":72,"props":2047,"children":2049},{"className":2048},[],[2050],{"type":48,"value":1980},{"type":48,"value":1320},{"type":43,"tag":72,"props":2053,"children":2055},{"className":2054},[],[2056],{"type":48,"value":1987},{"type":48,"value":2058}," (.NET, Java, JS\u002FTS, Kotlin, Swift, C++); ",{"type":43,"tag":72,"props":2060,"children":2062},{"className":2061},[],[2063],{"type":48,"value":1980},{"type":48,"value":1320},{"type":43,"tag":72,"props":2066,"children":2068},{"className":2067},[],[2069],{"type":48,"value":1994},{"type":48,"value":820},{"type":43,"tag":72,"props":2072,"children":2074},{"className":2073},[],[2075],{"type":48,"value":2076},"begin",{"type":48,"value":1320},{"type":43,"tag":72,"props":2079,"children":2081},{"className":2080},[],[2082],{"type":48,"value":2001},{"type":48,"value":915},{"type":43,"tag":72,"props":2085,"children":2087},{"className":2086},[],[2088],{"type":48,"value":2089},"defer recover()",{"type":48,"value":2091}," (Go); manual ",{"type":43,"tag":72,"props":2093,"children":2095},{"className":2094},[],[2096],{"type":48,"value":2097},"if err != nil { t.Fatal(err) }",{"type":48,"value":2099}," in Go is canonical and NOT a smell.\n",{"type":43,"tag":64,"props":2101,"children":2102},{},[2103],{"type":48,"value":1029},{"type":48,"value":1838},{"type":43,"tag":72,"props":2106,"children":2108},{"className":2107},[],[2109],{"type":48,"value":1987},{"type":48,"value":1320},{"type":43,"tag":72,"props":2112,"children":2114},{"className":2113},[],[2115],{"type":48,"value":1994},{"type":48,"value":1320},{"type":43,"tag":72,"props":2118,"children":2120},{"className":2119},[],[2121],{"type":48,"value":2001},{"type":48,"value":2123}," blocks that capture an exception for further assertion on its properties are a lesser concern — note but don't flag as high severity.",{"type":43,"tag":478,"props":2125,"children":2127},{"id":2126},"smell-9-general-fixture-over-broad-setup",[2128],{"type":48,"value":2129},"Smell 9: General Fixture (Over-broad Setup)",{"type":43,"tag":51,"props":2131,"children":2132},{},[2133],{"type":48,"value":2134},"The test setup method, constructor, or fixture initializes fields that are not used by every test method. This means each test pays the cost of setting up objects it doesn't need.",{"type":43,"tag":51,"props":2136,"children":2137},{},[2138,2142,2144,2148,2150,2156,2157,2163,2164,2170,2171,2177,2178,2184,2185,2191,2193,2199,2201,2207,2209,2215],{"type":43,"tag":64,"props":2139,"children":2140},{},[2141],{"type":48,"value":548},{"type":48,"value":2143}," Low\n",{"type":43,"tag":64,"props":2145,"children":2146},{},[2147],{"type":48,"value":555},{"type":48,"value":2149}," Fields\u002Fproperties initialized in ",{"type":43,"tag":72,"props":2151,"children":2153},{"className":2152},[],[2154],{"type":48,"value":2155},"[TestInitialize]",{"type":48,"value":623},{"type":43,"tag":72,"props":2158,"children":2160},{"className":2159},[],[2161],{"type":48,"value":2162},"setUp",{"type":48,"value":623},{"type":43,"tag":72,"props":2165,"children":2167},{"className":2166},[],[2168],{"type":48,"value":2169},"@BeforeEach",{"type":48,"value":623},{"type":43,"tag":72,"props":2172,"children":2174},{"className":2173},[],[2175],{"type":48,"value":2176},"beforeEach",{"type":48,"value":623},{"type":43,"tag":72,"props":2179,"children":2181},{"className":2180},[],[2182],{"type":48,"value":2183},"before(:each)",{"type":48,"value":623},{"type":43,"tag":72,"props":2186,"children":2188},{"className":2187},[],[2189],{"type":48,"value":2190},"BeforeEach",{"type":48,"value":2192}," (Pester) \u002F ",{"type":43,"tag":72,"props":2194,"children":2196},{"className":2195},[],[2197],{"type":48,"value":2198},"setUpWithError",{"type":48,"value":2200}," (XCTest) \u002F pytest ",{"type":43,"tag":72,"props":2202,"children":2204},{"className":2203},[],[2205],{"type":48,"value":2206},"fixture(autouse=True)",{"type":48,"value":2208}," \u002F xUnit constructor \u002F Kotest ",{"type":43,"tag":72,"props":2210,"children":2212},{"className":2211},[],[2213],{"type":48,"value":2214},"beforeTest",{"type":48,"value":2216}," that are referenced by fewer than half the test methods in the class\u002Fmodule\u002Ffile.",{"type":43,"tag":478,"props":2218,"children":2220},{"id":2219},"smell-10-ignored-disabled-skipped-test",[2221],{"type":48,"value":2222},"Smell 10: Ignored \u002F Disabled \u002F Skipped Test",{"type":43,"tag":51,"props":2224,"children":2225},{},[2226],{"type":48,"value":2227},"Tests marked as skipped or disabled. These add overhead and clutter, and the underlying issue they were disabled for may never be addressed.",{"type":43,"tag":51,"props":2229,"children":2230},{},[2231,2235,2236,2240,2242,2248,2250,2256,2258,2264,2265,2271,2273,2279,2281,2287,2288,2294,2295,2301,2302,2308,2309,2315,2316,2322,2323,2329,2331,2337,2338,2344,2345,2351,2352,2357,2359,2365,2367,2373,2374,2380,2381,2387,2389,2395,2397,2403,2404,2410,2412,2418,2420,2426],{"type":43,"tag":64,"props":2232,"children":2233},{},[2234],{"type":48,"value":548},{"type":48,"value":2143},{"type":43,"tag":64,"props":2237,"children":2238},{},[2239],{"type":48,"value":555},{"type":48,"value":2241}," Skip \u002F ignore \u002F disable annotations or conditional compilation that disables a test. See the loaded language extension file for framework-specific skip attributes — e.g., ",{"type":43,"tag":72,"props":2243,"children":2245},{"className":2244},[],[2246],{"type":48,"value":2247},"[Ignore]",{"type":48,"value":2249}," (MSTest\u002FNUnit), ",{"type":43,"tag":72,"props":2251,"children":2253},{"className":2252},[],[2254],{"type":48,"value":2255},"Skip = \"...\"",{"type":48,"value":2257}," (xUnit ",{"type":43,"tag":72,"props":2259,"children":2261},{"className":2260},[],[2262],{"type":48,"value":2263},"Fact",{"type":48,"value":518},{"type":43,"tag":72,"props":2266,"children":2268},{"className":2267},[],[2269],{"type":48,"value":2270},"@Ignore",{"type":48,"value":2272}," (TUnit\u002FJUnit 4), ",{"type":43,"tag":72,"props":2274,"children":2276},{"className":2275},[],[2277],{"type":48,"value":2278},"@Disabled",{"type":48,"value":2280}," (JUnit 5), ",{"type":43,"tag":72,"props":2282,"children":2284},{"className":2283},[],[2285],{"type":48,"value":2286},"@pytest.mark.skip",{"type":48,"value":623},{"type":43,"tag":72,"props":2289,"children":2291},{"className":2290},[],[2292],{"type":48,"value":2293},"pytest.skip(...)",{"type":48,"value":623},{"type":43,"tag":72,"props":2296,"children":2298},{"className":2297},[],[2299],{"type":48,"value":2300},"pytestmark",{"type":48,"value":418},{"type":43,"tag":72,"props":2303,"children":2305},{"className":2304},[],[2306],{"type":48,"value":2307},"it.skip",{"type":48,"value":623},{"type":43,"tag":72,"props":2310,"children":2312},{"className":2311},[],[2313],{"type":48,"value":2314},"xit",{"type":48,"value":623},{"type":43,"tag":72,"props":2317,"children":2319},{"className":2318},[],[2320],{"type":48,"value":2321},"describe.skip",{"type":48,"value":623},{"type":43,"tag":72,"props":2324,"children":2326},{"className":2325},[],[2327],{"type":48,"value":2328},"test.skip",{"type":48,"value":2330}," (Jest\u002FVitest\u002FMocha), ",{"type":43,"tag":72,"props":2332,"children":2334},{"className":2333},[],[2335],{"type":48,"value":2336},"t.Skip(...)",{"type":48,"value":1552},{"type":43,"tag":72,"props":2339,"children":2341},{"className":2340},[],[2342],{"type":48,"value":2343},"pending",{"type":48,"value":623},{"type":43,"tag":72,"props":2346,"children":2348},{"className":2347},[],[2349],{"type":48,"value":2350},"skip",{"type":48,"value":623},{"type":43,"tag":72,"props":2353,"children":2355},{"className":2354},[],[2356],{"type":48,"value":2314},{"type":48,"value":2358}," (RSpec), ",{"type":43,"tag":72,"props":2360,"children":2362},{"className":2361},[],[2363],{"type":48,"value":2364},"#[ignore]",{"type":48,"value":2366}," (Rust), ",{"type":43,"tag":72,"props":2368,"children":2370},{"className":2369},[],[2371],{"type":48,"value":2372},"XCTSkip",{"type":48,"value":623},{"type":43,"tag":72,"props":2375,"children":2377},{"className":2376},[],[2378],{"type":48,"value":2379},"@Test(.disabled)",{"type":48,"value":1591},{"type":43,"tag":72,"props":2382,"children":2384},{"className":2383},[],[2385],{"type":48,"value":2386},"@Ignored",{"type":48,"value":2388}," (Kotest), ",{"type":43,"tag":72,"props":2390,"children":2392},{"className":2391},[],[2393],{"type":48,"value":2394},"-Skip",{"type":48,"value":2396}," (Pester), ",{"type":43,"tag":72,"props":2398,"children":2400},{"className":2399},[],[2401],{"type":48,"value":2402},"GTEST_SKIP()",{"type":48,"value":623},{"type":43,"tag":72,"props":2405,"children":2407},{"className":2406},[],[2408],{"type":48,"value":2409},"DISABLED_TestName",{"type":48,"value":2411}," (GoogleTest), ",{"type":43,"tag":72,"props":2413,"children":2415},{"className":2414},[],[2416],{"type":48,"value":2417},"[.]",{"type":48,"value":2419}," tag (Catch2), ",{"type":43,"tag":72,"props":2421,"children":2423},{"className":2422},[],[2424],{"type":48,"value":2425},"TEST_CASE(\"...\", \"[.]\")",{"type":48,"value":2427}," skip.",{"type":43,"tag":393,"props":2429,"children":2431},{"id":2430},"step-4-apply-calibration-rules",[2432],{"type":48,"value":2433},"Step 4: Apply calibration rules",{"type":43,"tag":51,"props":2435,"children":2436},{},[2437],{"type":48,"value":2438},"Before reporting, calibrate findings to avoid false positives:",{"type":43,"tag":231,"props":2440,"children":2441},{},[2442,2466,2476,2559,2569,2586,2603,2613,2623,2633,2685],{"type":43,"tag":235,"props":2443,"children":2444},{},[2445,2450,2452,2457,2459,2464],{"type":43,"tag":64,"props":2446,"children":2447},{},[2448],{"type":48,"value":2449},"Integration tests have different norms — but not for sleeps.",{"type":48,"value":2451}," A test class clearly marked as integration (by name, annotation, category, or convention — see the loaded language extension file for markers) legitimately uses external resources and calls multiple methods. Downgrade Mystery Guest and Eager Test for integration tests. ",{"type":43,"tag":64,"props":2453,"children":2454},{},[2455],{"type":48,"value":2456},"Do NOT downgrade Sleepy Test:",{"type":48,"value":2458}," a fixed wall-clock sleep is non-deterministic and slow in any test category, so it stays a real High-severity smell — recommend polling\u002Fawaiting the condition with a timeout instead. Only treat a sleep as acceptable when it is bounded by a documented external constraint (e.g. a third-party rate limit) ",{"type":43,"tag":577,"props":2460,"children":2461},{},[2462],{"type":48,"value":2463},"and",{"type":48,"value":2465}," paired with a condition check.",{"type":43,"tag":235,"props":2467,"children":2468},{},[2469,2474],{"type":43,"tag":64,"props":2470,"children":2471},{},[2472],{"type":48,"value":2473},"Simple loop-assert patterns are fine.",{"type":48,"value":2475}," Iterating a collection to assert on every item is readable and correct. Only flag loops with complex branching logic.",{"type":43,"tag":235,"props":2477,"children":2478},{},[2479,2484,2486,2492,2494,2499,2501,2507,2509,2515,2517,2522,2524,2529,2531,2536,2538,2543,2544,2550,2552,2557],{"type":43,"tag":64,"props":2480,"children":2481},{},[2482],{"type":48,"value":2483},"Idiomatic table-driven and parametrized patterns are NOT Conditional Test Logic.",{"type":48,"value":2485}," Go's ",{"type":43,"tag":72,"props":2487,"children":2489},{"className":2488},[],[2490],{"type":48,"value":2491},"for _, tt := range tests { t.Run(...) }",{"type":48,"value":2493},", Rust's ",{"type":43,"tag":72,"props":2495,"children":2497},{"className":2496},[],[2498],{"type":48,"value":607},{"type":48,"value":2500},", pytest's ",{"type":43,"tag":72,"props":2502,"children":2504},{"className":2503},[],[2505],{"type":48,"value":2506},"@parametrize",{"type":48,"value":2508},", Jest\u002FVitest ",{"type":43,"tag":72,"props":2510,"children":2512},{"className":2511},[],[2513],{"type":48,"value":2514},".each",{"type":48,"value":2516},", JUnit ",{"type":43,"tag":72,"props":2518,"children":2520},{"className":2519},[],[2521],{"type":48,"value":650},{"type":48,"value":2523},", RSpec ",{"type":43,"tag":72,"props":2525,"children":2527},{"className":2526},[],[2528],{"type":48,"value":686},{"type":48,"value":2530},", Pester ",{"type":43,"tag":72,"props":2532,"children":2534},{"className":2533},[],[2535],{"type":48,"value":666},{"type":48,"value":2537},", Catch2 ",{"type":43,"tag":72,"props":2539,"children":2541},{"className":2540},[],[2542],{"type":48,"value":704},{"type":48,"value":1320},{"type":43,"tag":72,"props":2545,"children":2547},{"className":2546},[],[2548],{"type":48,"value":2549},"GENERATE",{"type":48,"value":2551},", GoogleTest ",{"type":43,"tag":72,"props":2553,"children":2555},{"className":2554},[],[2556],{"type":48,"value":736},{"type":48,"value":2558}," are canonical and must NOT be flagged.",{"type":43,"tag":235,"props":2560,"children":2561},{},[2562,2567],{"type":43,"tag":64,"props":2563,"children":2564},{},[2565],{"type":48,"value":2566},"Context matters for magic numbers.",{"type":48,"value":2568}," A count assertion right after adding a known number of items is self-documenting. Only flag numbers whose meaning requires looking at production code to understand.",{"type":43,"tag":235,"props":2570,"children":2571},{},[2572,2584],{"type":43,"tag":64,"props":2573,"children":2574},{},[2575,2577,2582],{"type":48,"value":2576},"Bare ",{"type":43,"tag":72,"props":2578,"children":2580},{"className":2579},[],[2581],{"type":48,"value":1251},{"type":48,"value":2583}," (pytest) is canonical, not assertion-free framework use.",{"type":48,"value":2585}," Don't flag.",{"type":43,"tag":235,"props":2587,"children":2588},{},[2589,2601],{"type":43,"tag":64,"props":2590,"children":2591},{},[2592,2594,2599],{"type":48,"value":2593},"Go's ",{"type":43,"tag":72,"props":2595,"children":2597},{"className":2596},[],[2598],{"type":48,"value":2097},{"type":48,"value":2600}," is canonical",{"type":48,"value":2602},", not Exception Handling in Tests. Don't flag.",{"type":43,"tag":235,"props":2604,"children":2605},{},[2606,2611],{"type":43,"tag":64,"props":2607,"children":2608},{},[2609],{"type":48,"value":2610},"Mock-call verifications and snapshot assertions are real assertions",{"type":48,"value":2612}," — do not flag tests using them as Assertion-Free.",{"type":43,"tag":235,"props":2614,"children":2615},{},[2616,2621],{"type":43,"tag":64,"props":2617,"children":2618},{},[2619],{"type":48,"value":2620},"Missing-await on async assertions is its own critical sub-smell of Assertion-Free",{"type":48,"value":2622}," — these tests silently pass even when the underlying assertion fails. Always flag when detected.",{"type":43,"tag":235,"props":2624,"children":2625},{},[2626,2631],{"type":43,"tag":64,"props":2627,"children":2628},{},[2629],{"type":48,"value":2630},"Inconclusive\u002Fpending markers are not assertion-free.",{"type":48,"value":2632}," Tests explicitly marked as incomplete should be flagged as Ignored Test, not Assertion-Free.",{"type":43,"tag":235,"props":2634,"children":2635},{},[2636,2641,2642,2648,2650,2656,2657,2662,2663,2669,2670,2676,2677,2683],{"type":43,"tag":64,"props":2637,"children":2638},{},[2639],{"type":48,"value":2640},"Capture-and-assert exception patterns are borderline.",{"type":48,"value":1838},{"type":43,"tag":72,"props":2643,"children":2645},{"className":2644},[],[2646],{"type":48,"value":2647},"try { ... } catch (X x) { Assert.Equal(...) }",{"type":48,"value":2649}," style patterns are ugly but functional. Note as a smell and suggest the framework's built-in exception assertion (",{"type":43,"tag":72,"props":2651,"children":2653},{"className":2652},[],[2654],{"type":48,"value":2655},"Assert.Throws\u003CT>",{"type":48,"value":418},{"type":43,"tag":72,"props":2658,"children":2660},{"className":2659},[],[2661],{"type":48,"value":1258},{"type":48,"value":418},{"type":43,"tag":72,"props":2664,"children":2666},{"className":2665},[],[2667],{"type":48,"value":2668},"expect(fn).toThrow",{"type":48,"value":418},{"type":43,"tag":72,"props":2671,"children":2673},{"className":2672},[],[2674],{"type":48,"value":2675},"assertThrows",{"type":48,"value":418},{"type":43,"tag":72,"props":2678,"children":2680},{"className":2679},[],[2681],{"type":48,"value":2682},"assert.PanicsWithError",{"type":48,"value":2684},", etc.) instead of calling it broken.",{"type":43,"tag":235,"props":2686,"children":2687},{},[2688,2693],{"type":43,"tag":64,"props":2689,"children":2690},{},[2691],{"type":48,"value":2692},"If the test suite is clean, say so.",{"type":48,"value":2694}," A report finding few or no smells is perfectly valid.",{"type":43,"tag":393,"props":2696,"children":2698},{"id":2697},"step-5-report-findings",[2699],{"type":48,"value":2700},"Step 5: Report findings",{"type":43,"tag":51,"props":2702,"children":2703},{},[2704],{"type":48,"value":2705},"Present the analysis in this structure:",{"type":43,"tag":2707,"props":2708,"children":2709},"ol",{},[2710,2732,2775,2785],{"type":43,"tag":235,"props":2711,"children":2712},{},[2713,2718,2720],{"type":43,"tag":64,"props":2714,"children":2715},{},[2716],{"type":48,"value":2717},"Summary Dashboard",{"type":48,"value":2719}," — Quick overview:",{"type":43,"tag":2721,"props":2722,"children":2726},"pre",{"className":2723,"code":2725,"language":48},[2724],"language-text","| Severity | Smell Count | Affected Tests |\n|----------|-------------|----------------|\n| High     | 3           | 7              |\n| Medium   | 2           | 4              |\n| Low      | 1           | 2              |\n| Total    | 6           | 13             |\n",[2727],{"type":43,"tag":72,"props":2728,"children":2730},{"__ignoreMap":2729},"",[2731],{"type":48,"value":2725},{"type":43,"tag":235,"props":2733,"children":2734},{},[2735,2740,2742],{"type":43,"tag":64,"props":2736,"children":2737},{},[2738],{"type":48,"value":2739},"Findings by Severity",{"type":48,"value":2741}," — For each smell found:",{"type":43,"tag":231,"props":2743,"children":2744},{},[2745,2750,2755,2760,2765,2770],{"type":43,"tag":235,"props":2746,"children":2747},{},[2748],{"type":48,"value":2749},"Smell name and category",{"type":43,"tag":235,"props":2751,"children":2752},{},[2753],{"type":48,"value":2754},"Severity level with rationale",{"type":43,"tag":235,"props":2756,"children":2757},{},[2758],{"type":48,"value":2759},"Affected test methods (file and method name)",{"type":43,"tag":235,"props":2761,"children":2762},{},[2763],{"type":48,"value":2764},"Code snippet showing the smell",{"type":43,"tag":235,"props":2766,"children":2767},{},[2768],{"type":48,"value":2769},"Concrete fix: show what the code should look like after remediation",{"type":43,"tag":235,"props":2771,"children":2772},{},[2773],{"type":48,"value":2774},"Risk if left unfixed",{"type":43,"tag":235,"props":2776,"children":2777},{},[2778,2783],{"type":43,"tag":64,"props":2779,"children":2780},{},[2781],{"type":48,"value":2782},"Smell-Free Patterns",{"type":48,"value":2784}," — If any test methods are well-written, briefly acknowledge this. Highlighting what's good helps the user understand the contrast.",{"type":43,"tag":235,"props":2786,"children":2787},{},[2788,2793,2795],{"type":43,"tag":64,"props":2789,"children":2790},{},[2791],{"type":48,"value":2792},"Prioritized Remediation Plan",{"type":48,"value":2794}," — Rank fixes by:",{"type":43,"tag":231,"props":2796,"children":2797},{},[2798,2803,2808],{"type":43,"tag":235,"props":2799,"children":2800},{},[2801],{"type":48,"value":2802},"Impact (high-severity smells affecting many tests first)",{"type":43,"tag":235,"props":2804,"children":2805},{},[2806],{"type":48,"value":2807},"Effort (quick fixes before refactoring)",{"type":43,"tag":235,"props":2809,"children":2810},{},[2811],{"type":48,"value":2812},"Risk (fixes that prevent false-passes before cosmetic improvements)",{"type":43,"tag":81,"props":2814,"children":2816},{"id":2815},"validation",[2817],{"type":48,"value":2818},"Validation",{"type":43,"tag":231,"props":2820,"children":2823},{"className":2821},[2822],"contains-task-list",[2824,2837,2846,2855,2864,2873,2882,2891,2900],{"type":43,"tag":235,"props":2825,"children":2828},{"className":2826},[2827],"task-list-item",[2829,2835],{"type":43,"tag":2830,"props":2831,"children":2834},"input",{"disabled":2832,"type":2833},true,"checkbox",[],{"type":48,"value":2836}," Every finding includes the specific test method name and file location",{"type":43,"tag":235,"props":2838,"children":2840},{"className":2839},[2827],[2841,2844],{"type":43,"tag":2830,"props":2842,"children":2843},{"disabled":2832,"type":2833},[],{"type":48,"value":2845}," Every finding includes a code snippet showing the smell in context",{"type":43,"tag":235,"props":2847,"children":2849},{"className":2848},[2827],[2850,2853],{"type":43,"tag":2830,"props":2851,"children":2852},{"disabled":2832,"type":2833},[],{"type":48,"value":2854}," Every finding includes a concrete fix example (not just \"fix this\")",{"type":43,"tag":235,"props":2856,"children":2858},{"className":2857},[2827],[2859,2862],{"type":43,"tag":2830,"props":2860,"children":2861},{"disabled":2832,"type":2833},[],{"type":48,"value":2863}," Integration tests are not penalized for using real resources, but their fixed sleeps are still reported as High",{"type":43,"tag":235,"props":2865,"children":2867},{"className":2866},[2827],[2868,2871],{"type":43,"tag":2830,"props":2869,"children":2870},{"disabled":2832,"type":2833},[],{"type":48,"value":2872}," Each smell is reported under its own taxonomy name (Unknown Test, Empty Test, Assertion Roulette are distinct — do not merge them)",{"type":43,"tag":235,"props":2874,"children":2876},{"className":2875},[2827],[2877,2880],{"type":43,"tag":2830,"props":2878,"children":2879},{"disabled":2832,"type":2833},[],{"type":48,"value":2881}," Simple foreach-assert loops are not flagged as conditional test logic",{"type":43,"tag":235,"props":2883,"children":2885},{"className":2884},[2827],[2886,2889],{"type":43,"tag":2830,"props":2887,"children":2888},{"disabled":2832,"type":2833},[],{"type":48,"value":2890}," Contextually obvious numbers are not flagged as magic numbers",{"type":43,"tag":235,"props":2892,"children":2894},{"className":2893},[2827],[2895,2898],{"type":43,"tag":2830,"props":2896,"children":2897},{"disabled":2832,"type":2833},[],{"type":48,"value":2899}," If the test suite is clean, the report says so upfront",{"type":43,"tag":235,"props":2901,"children":2903},{"className":2902},[2827],[2904,2907],{"type":43,"tag":2830,"props":2905,"children":2906},{"disabled":2832,"type":2833},[],{"type":48,"value":2908}," Severity levels are justified, not arbitrary",{"type":43,"tag":81,"props":2910,"children":2912},{"id":2911},"common-pitfalls",[2913],{"type":48,"value":2914},"Common Pitfalls",{"type":43,"tag":93,"props":2916,"children":2917},{},[2918,2934],{"type":43,"tag":97,"props":2919,"children":2920},{},[2921],{"type":43,"tag":101,"props":2922,"children":2923},{},[2924,2929],{"type":43,"tag":105,"props":2925,"children":2926},{},[2927],{"type":48,"value":2928},"Pitfall",{"type":43,"tag":105,"props":2930,"children":2931},{},[2932],{"type":48,"value":2933},"Solution",{"type":43,"tag":116,"props":2935,"children":2936},{},[2937,2950,2969,2982,3007,3069,3082,3134,3176,3222,3235,3270],{"type":43,"tag":101,"props":2938,"children":2939},{},[2940,2945],{"type":43,"tag":123,"props":2941,"children":2942},{},[2943],{"type":48,"value":2944},"Flagging integration tests for using real resources",{"type":43,"tag":123,"props":2946,"children":2947},{},[2948],{"type":48,"value":2949},"Check for integration test markers (per the loaded language extension) and adjust severity accordingly — external resources and multi-step flows are expected there",{"type":43,"tag":101,"props":2951,"children":2952},{},[2953,2958],{"type":43,"tag":123,"props":2954,"children":2955},{},[2956],{"type":48,"value":2957},"Calibrating away a real sleep as an \"integration style issue\"",{"type":43,"tag":123,"props":2959,"children":2960},{},[2961,2967],{"type":43,"tag":72,"props":2962,"children":2964},{"className":2963},[],[2965],{"type":48,"value":2966},"Thread.Sleep(3000)",{"type":48,"value":2968}," in an integration test is still a High-severity Sleepy Test; recommend a polled wait with timeout",{"type":43,"tag":101,"props":2970,"children":2971},{},[2972,2977],{"type":43,"tag":123,"props":2973,"children":2974},{},[2975],{"type":48,"value":2976},"Flagging loop-over-collection-assert as conditional logic",{"type":43,"tag":123,"props":2978,"children":2979},{},[2980],{"type":48,"value":2981},"Only flag loops with branching or complex logic, not assertion iterations",{"type":43,"tag":101,"props":2983,"children":2984},{},[2985,2990],{"type":43,"tag":123,"props":2986,"children":2987},{},[2988],{"type":48,"value":2989},"Flagging Go\u002FRust table-driven loops as Conditional Test Logic",{"type":43,"tag":123,"props":2991,"children":2992},{},[2993,2998,3000,3005],{"type":43,"tag":72,"props":2994,"children":2996},{"className":2995},[],[2997],{"type":48,"value":2491},{"type":48,"value":2999}," (Go) and ",{"type":43,"tag":72,"props":3001,"children":3003},{"className":3002},[],[3004],{"type":48,"value":607},{"type":48,"value":3006}," loops (Rust) are canonical and must NOT be flagged",{"type":43,"tag":101,"props":3008,"children":3009},{},[3010,3015],{"type":43,"tag":123,"props":3011,"children":3012},{},[3013],{"type":48,"value":3014},"Flagging parametrized tests as Duplicate Assert",{"type":43,"tag":123,"props":3016,"children":3017},{},[3018,3023,3024,3030,3031,3037,3038,3043,3044,3049,3050,3055,3056,3061,3062,3067],{"type":43,"tag":72,"props":3019,"children":3021},{"className":3020},[],[3022],{"type":48,"value":636},{"type":48,"value":418},{"type":43,"tag":72,"props":3025,"children":3027},{"className":3026},[],[3028],{"type":48,"value":3029},"it.each",{"type":48,"value":418},{"type":43,"tag":72,"props":3032,"children":3034},{"className":3033},[],[3035],{"type":48,"value":3036},"[Theory]+[InlineData]",{"type":48,"value":418},{"type":43,"tag":72,"props":3039,"children":3041},{"className":3040},[],[3042],{"type":48,"value":650},{"type":48,"value":2523},{"type":43,"tag":72,"props":3045,"children":3047},{"className":3046},[],[3048],{"type":48,"value":686},{"type":48,"value":2530},{"type":43,"tag":72,"props":3051,"children":3053},{"className":3052},[],[3054],{"type":48,"value":666},{"type":48,"value":2537},{"type":43,"tag":72,"props":3057,"children":3059},{"className":3058},[],[3060],{"type":48,"value":704},{"type":48,"value":1320},{"type":43,"tag":72,"props":3063,"children":3065},{"className":3064},[],[3066],{"type":48,"value":2549},{"type":48,"value":3068}," are correct deduplication, not smells",{"type":43,"tag":101,"props":3070,"children":3071},{},[3072,3077],{"type":43,"tag":123,"props":3073,"children":3074},{},[3075],{"type":48,"value":3076},"Flagging obvious count assertions after adding N items",{"type":43,"tag":123,"props":3078,"children":3079},{},[3080],{"type":48,"value":3081},"Consider the immediate context — self-documenting numbers are fine",{"type":43,"tag":101,"props":3083,"children":3084},{},[3085,3090],{"type":43,"tag":123,"props":3086,"children":3087},{},[3088],{"type":48,"value":3089},"Missing framework-specific assertion syntax",{"type":43,"tag":123,"props":3091,"children":3092},{},[3093,3095,3101,3103,3109,3111,3117,3119,3124,3126,3132],{"type":48,"value":3094},"Always read the matching language extension file first; each framework has distinct assertion APIs (xUnit ",{"type":43,"tag":72,"props":3096,"children":3098},{"className":3097},[],[3099],{"type":48,"value":3100},"Assert.Equal",{"type":48,"value":3102},", MSTest ",{"type":43,"tag":72,"props":3104,"children":3106},{"className":3105},[],[3107],{"type":48,"value":3108},"Assert.AreEqual",{"type":48,"value":3110},", NUnit ",{"type":43,"tag":72,"props":3112,"children":3114},{"className":3113},[],[3115],{"type":48,"value":3116},"Is.EqualTo",{"type":48,"value":3118},", pytest bare ",{"type":43,"tag":72,"props":3120,"children":3122},{"className":3121},[],[3123],{"type":48,"value":1251},{"type":48,"value":3125},", Jest ",{"type":43,"tag":72,"props":3127,"children":3129},{"className":3128},[],[3130],{"type":48,"value":3131},"expect().toBe()",{"type":48,"value":3133},", etc.)",{"type":43,"tag":101,"props":3135,"children":3136},{},[3137,3142],{"type":43,"tag":123,"props":3138,"children":3139},{},[3140],{"type":48,"value":3141},"Treating mock-call verifications as assertion-free",{"type":43,"tag":123,"props":3143,"children":3144},{},[3145,3150,3151,3156,3157,3162,3163,3168,3169,3174],{"type":43,"tag":72,"props":3146,"children":3148},{"className":3147},[],[3149],{"type":48,"value":1485},{"type":48,"value":418},{"type":43,"tag":72,"props":3152,"children":3154},{"className":3153},[],[3155],{"type":48,"value":1509},{"type":48,"value":418},{"type":43,"tag":72,"props":3158,"children":3160},{"className":3159},[],[3161],{"type":48,"value":1525},{"type":48,"value":418},{"type":43,"tag":72,"props":3164,"children":3166},{"className":3165},[],[3167],{"type":48,"value":1517},{"type":48,"value":418},{"type":43,"tag":72,"props":3170,"children":3172},{"className":3171},[],[3173],{"type":48,"value":1501},{"type":48,"value":3175}," are real assertions",{"type":43,"tag":101,"props":3177,"children":3178},{},[3179,3184],{"type":43,"tag":123,"props":3180,"children":3181},{},[3182],{"type":48,"value":3183},"Missing the async-test silent-pass trap",{"type":43,"tag":123,"props":3185,"children":3186},{},[3187,3189,3194,3195,3200,3201,3206,3208,3213,3215,3220],{"type":48,"value":3188},"Always flag ",{"type":43,"tag":72,"props":3190,"children":3192},{"className":3191},[],[3193],{"type":48,"value":1614},{"type":48,"value":1616},{"type":43,"tag":72,"props":3196,"children":3198},{"className":3197},[],[3199],{"type":48,"value":1622},{"type":48,"value":1320},{"type":43,"tag":72,"props":3202,"children":3204},{"className":3203},[],[3205],{"type":48,"value":1629},{"type":48,"value":3207},", un-awaited ",{"type":43,"tag":72,"props":3209,"children":3211},{"className":3210},[],[3212],{"type":48,"value":1637},{"type":48,"value":3214}," (xUnit), un-awaited coroutines in pytest-asyncio, missing ",{"type":43,"tag":72,"props":3216,"children":3218},{"className":3217},[],[3219],{"type":48,"value":1653},{"type":48,"value":3221}," in Kotest, un-awaited Swift Testing async assertions",{"type":43,"tag":101,"props":3223,"children":3224},{},[3225,3230],{"type":43,"tag":123,"props":3226,"children":3227},{},[3228],{"type":48,"value":3229},"Over-flagging try\u002Fcatch that captures for assertion",{"type":43,"tag":123,"props":3231,"children":3232},{},[3233],{"type":48,"value":3234},"Distinguish swallowed exceptions from capture-and-assert patterns",{"type":43,"tag":101,"props":3236,"children":3237},{},[3238,3243],{"type":43,"tag":123,"props":3239,"children":3240},{},[3241],{"type":48,"value":3242},"Treating skip annotations with reasons same as bare skips",{"type":43,"tag":123,"props":3244,"children":3245},{},[3246,3248,3254,3255,3261,3262,3268],{"type":48,"value":3247},"Note that reasoned skips (",{"type":43,"tag":72,"props":3249,"children":3251},{"className":3250},[],[3252],{"type":48,"value":3253},"Skip = \"Tracked by #123\"",{"type":48,"value":418},{"type":43,"tag":72,"props":3256,"children":3258},{"className":3257},[],[3259],{"type":48,"value":3260},"@pytest.mark.skip(reason=\"...\")",{"type":48,"value":418},{"type":43,"tag":72,"props":3263,"children":3265},{"className":3264},[],[3266],{"type":48,"value":3267},"t.Skip(\"not yet implemented\")",{"type":48,"value":3269},") are less concerning than unexplained ones",{"type":43,"tag":101,"props":3271,"children":3272},{},[3273,3286],{"type":43,"tag":123,"props":3274,"children":3275},{},[3276,3278,3284],{"type":48,"value":3277},"Flagging ",{"type":43,"tag":72,"props":3279,"children":3281},{"className":3280},[],[3282],{"type":48,"value":3283},"DoesNotThrow",{"type":48,"value":3285},"-style tests as assertion-free",{"type":43,"tag":123,"props":3287,"children":3288},{},[3289],{"type":48,"value":3290},"These implicitly assert no exception — note but acknowledge the intent",{"items":3292,"total":3452},[3293,3311,3322,3337,3355,3366,3386,3396,3408,3418,3431,3442],{"slug":3294,"name":3294,"fn":3295,"description":3296,"org":3297,"tags":3298,"stars":3308,"repoUrl":3309,"updatedAt":3310},"multithreaded-task-migration","migrate MSBuild tasks to multithreaded mode","Guide for migrating MSBuild tasks to multithreaded mode support, including compatibility red-team review. Use this when converting tasks to thread-safe versions, implementing IMultiThreadableTask, adding TaskEnvironment support, or auditing migrations for behavioral compatibility.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3299,3302,3305],{"name":3300,"slug":3301,"type":15},".NET","net",{"name":3303,"slug":3304,"type":15},"Engineering","engineering",{"name":3306,"slug":3307,"type":15},"Performance","performance",5535,"https:\u002F\u002Fgithub.com\u002Fdotnet\u002Fmsbuild","2026-07-22T05:37:33.965588",{"slug":3312,"name":3312,"fn":3313,"description":3314,"org":3315,"tags":3316,"stars":25,"repoUrl":26,"updatedAt":3321},"analyzing-dotnet-performance","analyze .NET code for performance anti-patterns","Scans .NET code for ~50 performance anti-patterns across async, memory, strings, collections, LINQ, regex, serialization, and I\u002FO with tiered severity classification. Use when analyzing .NET code for optimization opportunities, reviewing hot paths, or auditing allocation-heavy patterns.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3317,3318,3319,3320],{"name":3300,"slug":3301,"type":15},{"name":17,"slug":18,"type":15},{"name":23,"slug":24,"type":15},{"name":3306,"slug":3307,"type":15},"2026-07-12T08:23:25.400375",{"slug":3323,"name":3323,"fn":3324,"description":3325,"org":3326,"tags":3327,"stars":25,"repoUrl":26,"updatedAt":3336},"android-tombstone-symbolication","symbolicate .NET runtime frames in Android tombstones","Symbolicate the .NET runtime frames in an Android tombstone file. Extracts BuildIds and PC offsets from the native backtrace, downloads debug symbols from the Microsoft symbol server, and runs llvm-symbolizer to produce function names with source file and line numbers. USE FOR triaging a .NET MAUI or Mono Android app crash from a tombstone, resolving native backtrace frames in libmonosgen-2.0.so or libcoreclr.so to .NET runtime source code, or investigating SIGABRT, SIGSEGV, or other native signals originating from the .NET runtime on Android. DO NOT USE FOR pure Java\u002FKotlin crashes, managed .NET exceptions that are already captured in logcat, or iOS crash logs. INVOKES Symbolicate-Tombstone.ps1 script, llvm-symbolizer, Microsoft symbol server.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3328,3329,3332,3333],{"name":3300,"slug":3301,"type":15},{"name":3330,"slug":3331,"type":15},"Android","android",{"name":23,"slug":24,"type":15},{"name":3334,"slug":3335,"type":15},"Microsoft","microsoft","2026-07-12T08:23:21.595572",{"slug":3338,"name":3338,"fn":3339,"description":3340,"org":3341,"tags":3342,"stars":25,"repoUrl":26,"updatedAt":3354},"apple-crash-symbolication","symbolicate .NET runtime frames in crash logs","Symbolicate .NET runtime frames in Apple platform .ips crash logs (iOS, tvOS, Mac Catalyst, macOS). Extracts UUIDs and addresses from the native backtrace, locates dSYM debug symbols, and runs atos to produce function names with source file and line numbers. Automatically downloads .dwarf symbols from the Microsoft symbol server using Mach-O UUIDs. USE FOR triaging a .NET MAUI or Mono app crash from an .ips file on any Apple platform, resolving native backtrace frames in libcoreclr or libmonosgen-2.0 to .NET runtime source code, retrieving .ips crash logs from a connected iOS device or iPhone, or investigating EXC_CRASH, EXC_BAD_ACCESS, SIGABRT, or SIGSEGV originating from the .NET runtime. DO NOT USE FOR pure Swift\u002FObjective-C crashes with no .NET components, or Android tombstone files. INVOKES Symbolicate-Crash.ps1 script, atos, dwarfdump, idevicecrashreport.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3343,3344,3345,3348,3351],{"name":3300,"slug":3301,"type":15},{"name":23,"slug":24,"type":15},{"name":3346,"slug":3347,"type":15},"iOS","ios",{"name":3349,"slug":3350,"type":15},"macOS","macos",{"name":3352,"slug":3353,"type":15},"Observability","observability","2026-07-12T08:23:20.369986",{"slug":292,"name":292,"fn":3356,"description":3357,"org":3358,"tags":3359,"stars":25,"repoUrl":26,"updatedAt":3365},"evaluate assertion quality in test suites","Analyzes the variety and depth of assertions across test suites in any language. Use when the user asks to evaluate assertion quality, find shallow tests, identify assertion-free tests (no assertions or only trivial ones like Assert.IsNotNull \u002F toBeTruthy()), flag self-referential or tautological assertions, measure assertion diversity, or audit whether tests verify different facets of behavior. Polyglot: .NET, Python, TS\u002FJS, Java, Go, Ruby, Rust, Swift, Kotlin, PowerShell, C++. DO NOT USE FOR: writing new tests (use code-testing-agent \u002F writing-mstest-tests), mutation reasoning about whether tests would catch a bug (use test-gap-analysis), or a general severity-ranked anti-pattern audit (use test-anti-patterns), fixing or rewriting assertions, or writing, fixing, or modernizing MSTest tests, assertions, or attributes (use writing-mstest-tests).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3360,3361,3364],{"name":17,"slug":18,"type":15},{"name":3362,"slug":3363,"type":15},"QA","qa",{"name":20,"slug":21,"type":15},"2026-07-12T08:23:51.277743",{"slug":3367,"name":3367,"fn":3368,"description":3369,"org":3370,"tags":3371,"stars":25,"repoUrl":26,"updatedAt":3385},"author-component","create and review Blazor components","Create or review Blazor components (.razor files) with correct architecture. USE FOR: writing new Blazor components that do NOT involve JavaScript interop, implementing parameters and EventCallback, RenderFragment slots, component lifecycle (OnInitializedAsync, OnParametersSet), async patterns, IAsyncDisposable, CancellationToken, CSS isolation, code-behind. DO NOT USE FOR: creating new projects (use create-blazor-project), JavaScript interop or calling browser APIs from Blazor (use use-js-interop), forms and validation (use collect-user-input), prerendering issues (use support-prerendering), HTTP data fetching patterns (use fetch-and-send-data), coordinating state between unrelated components (use coordinate-components).\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3372,3373,3376,3379,3382],{"name":3300,"slug":3301,"type":15},{"name":3374,"slug":3375,"type":15},"Blazor","blazor",{"name":3377,"slug":3378,"type":15},"C#","csharp",{"name":3380,"slug":3381,"type":15},"UI Components","ui-components",{"name":3383,"slug":3384,"type":15},"Web Development","web-development","2026-07-15T06:03:29.216359",{"slug":3387,"name":3387,"fn":3388,"description":3389,"org":3390,"tags":3391,"stars":25,"repoUrl":26,"updatedAt":3395},"binlog-failure-analysis","analyze MSBuild binary logs","Analyze MSBuild binary logs to diagnose build failures. USE FOR: build errors that are unclear from console output, diagnosing cascading failures across multi-project builds, tracing MSBuild target execution order, and generally any MSBuild build issues. Requires an existing .binlog file. DO NOT USE FOR: generating binlogs (use binlog-generation), non-MSBuild build systems.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3392,3393,3394],{"name":17,"slug":18,"type":15},{"name":23,"slug":24,"type":15},{"name":3334,"slug":3335,"type":15},"2026-07-12T08:21:34.637923",{"slug":3397,"name":3397,"fn":3398,"description":3399,"org":3400,"tags":3401,"stars":25,"repoUrl":26,"updatedAt":3407},"binlog-generation","generate MSBuild binary logs for diagnostics","Generate MSBuild binary logs (binlogs) for build diagnostics and analysis. USE FOR: adding \u002Fbl:{} to any dotnet build, test, pack, publish, or restore command to capture a full build execution trace, prerequisite for binlog-failure-analysis and build-perf-diagnostics skills, enabling post-build investigation of errors or performance. Requires MSBuild 17.8+ \u002F .NET 8 SDK+ for {} placeholder; PowerShell needs -bl:{{}}. DO NOT USE FOR: non-MSBuild build systems (npm, Maven, CMake), analyzing an existing binlog (use binlog-failure-analysis instead).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3402,3405,3406],{"name":3403,"slug":3404,"type":15},"Build","build",{"name":23,"slug":24,"type":15},{"name":3303,"slug":3304,"type":15},"2026-07-19T05:38:19.340791",{"slug":3409,"name":3409,"fn":3410,"description":3411,"org":3412,"tags":3413,"stars":25,"repoUrl":26,"updatedAt":3417},"build-parallelism","optimize MSBuild build parallelism","Diagnose and fix under-parallelized MSBuild builds. USE WHEN a multi-project solution build is slower than expected, doesn't speed up when you add cores, pegs a single core while others idle, or you want to know why `-m` isn't helping. Note: `\u002Fmaxcpucount` default is 1 (sequential) — always pass `-m` for parallel builds. Covers finding the critical path (longest serial ProjectReference chain), graph build (`\u002Fgraph`), BuildInParallel, and solution filters (`.slnf`). DO NOT USE FOR: single-project builds, incremental issues (use incremental-build), compilation slowness inside one project (use build-perf-diagnostics), non-MSBuild build systems.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3414,3415,3416],{"name":3300,"slug":3301,"type":15},{"name":3303,"slug":3304,"type":15},{"name":3306,"slug":3307,"type":15},"2026-07-19T05:38:18.364937",{"slug":3419,"name":3419,"fn":3420,"description":3421,"org":3422,"tags":3423,"stars":25,"repoUrl":26,"updatedAt":3430},"build-perf-baseline","establish and optimize build performance baselines","Establish build performance baselines and apply systematic optimization techniques. USE FOR: diagnosing slow builds, establishing before\u002Fafter measurements (cold, warm, no-op scenarios), applying optimization strategies like MSBuild Server, static graph builds, artifacts output, and dependency graph trimming. Start here before diving into build-perf-diagnostics, incremental-build, or build-parallelism. DO NOT USE FOR: non-MSBuild build systems, detailed bottleneck analysis (use build-perf-diagnostics after baselining).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3424,3425,3428,3429],{"name":3303,"slug":3304,"type":15},{"name":3426,"slug":3427,"type":15},"Monitoring","monitoring",{"name":3306,"slug":3307,"type":15},{"name":20,"slug":21,"type":15},"2026-07-12T08:21:35.865649",{"slug":3432,"name":3432,"fn":3433,"description":3434,"org":3435,"tags":3436,"stars":25,"repoUrl":26,"updatedAt":3441},"build-perf-diagnostics","diagnose MSBuild build performance bottlenecks","Diagnose MSBuild build performance bottlenecks using binary log analysis. USE FOR: identifying why builds are slow by analyzing binlog performance summaries, detecting ResolveAssemblyReference (RAR) taking >5s, Roslyn analyzers consuming >30% of Csc time, single targets dominating >50% of build time, node utilization below 80%, excessive Copy tasks, NuGet restore running every build. Covers timeline analysis, Target\u002FTask Performance Summary interpretation, and 7 common bottleneck categories. Use after build-perf-baseline has established measurements. DO NOT USE FOR: establishing initial baselines (use build-perf-baseline first), fixing incremental build issues (use incremental-build), parallelism tuning (use build-parallelism), non-MSBuild build systems.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3437,3438,3439,3440],{"name":3300,"slug":3301,"type":15},{"name":23,"slug":24,"type":15},{"name":3303,"slug":3304,"type":15},{"name":3306,"slug":3307,"type":15},"2026-07-12T08:21:40.961722",{"slug":3443,"name":3443,"fn":3444,"description":3445,"org":3446,"tags":3447,"stars":25,"repoUrl":26,"updatedAt":3451},"check-bin-obj-clash","detect MSBuild output path conflicts","Detects MSBuild projects with conflicting OutputPath or IntermediateOutputPath. USE FOR: builds failing with 'Cannot create a file when that file already exists', 'The process cannot access the file because it is being used by another process', intermittent build failures that succeed on retry, or missing\u002Foverwritten outputs in multi-project or multi-targeting builds where bin\u002Fobj (or project.assets.json) collide. Common causes: shared OutputPath, missing AppendTargetFrameworkToOutputPath, extra global properties (e.g. PublishReadyToRun), or SetTargetFramework on a ProjectReference to a single-targeting project. DO NOT USE FOR: file access errors unrelated to MSBuild (OS-level locking), single-project single-TFM builds, non-MSBuild build systems.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3448,3449,3450],{"name":23,"slug":24,"type":15},{"name":3303,"slug":3304,"type":15},{"name":3362,"slug":3363,"type":15},"2026-07-19T05:38:14.336279",144,{"items":3454,"total":3503},[3455,3462,3469,3477,3483,3491,3497],{"slug":3312,"name":3312,"fn":3313,"description":3314,"org":3456,"tags":3457,"stars":25,"repoUrl":26,"updatedAt":3321},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3458,3459,3460,3461],{"name":3300,"slug":3301,"type":15},{"name":17,"slug":18,"type":15},{"name":23,"slug":24,"type":15},{"name":3306,"slug":3307,"type":15},{"slug":3323,"name":3323,"fn":3324,"description":3325,"org":3463,"tags":3464,"stars":25,"repoUrl":26,"updatedAt":3336},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3465,3466,3467,3468],{"name":3300,"slug":3301,"type":15},{"name":3330,"slug":3331,"type":15},{"name":23,"slug":24,"type":15},{"name":3334,"slug":3335,"type":15},{"slug":3338,"name":3338,"fn":3339,"description":3340,"org":3470,"tags":3471,"stars":25,"repoUrl":26,"updatedAt":3354},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3472,3473,3474,3475,3476],{"name":3300,"slug":3301,"type":15},{"name":23,"slug":24,"type":15},{"name":3346,"slug":3347,"type":15},{"name":3349,"slug":3350,"type":15},{"name":3352,"slug":3353,"type":15},{"slug":292,"name":292,"fn":3356,"description":3357,"org":3478,"tags":3479,"stars":25,"repoUrl":26,"updatedAt":3365},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3480,3481,3482],{"name":17,"slug":18,"type":15},{"name":3362,"slug":3363,"type":15},{"name":20,"slug":21,"type":15},{"slug":3367,"name":3367,"fn":3368,"description":3369,"org":3484,"tags":3485,"stars":25,"repoUrl":26,"updatedAt":3385},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3486,3487,3488,3489,3490],{"name":3300,"slug":3301,"type":15},{"name":3374,"slug":3375,"type":15},{"name":3377,"slug":3378,"type":15},{"name":3380,"slug":3381,"type":15},{"name":3383,"slug":3384,"type":15},{"slug":3387,"name":3387,"fn":3388,"description":3389,"org":3492,"tags":3493,"stars":25,"repoUrl":26,"updatedAt":3395},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3494,3495,3496],{"name":17,"slug":18,"type":15},{"name":23,"slug":24,"type":15},{"name":3334,"slug":3335,"type":15},{"slug":3397,"name":3397,"fn":3398,"description":3399,"org":3498,"tags":3499,"stars":25,"repoUrl":26,"updatedAt":3407},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[3500,3501,3502],{"name":3403,"slug":3404,"type":15},{"name":23,"slug":24,"type":15},{"name":3303,"slug":3304,"type":15},96]