[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M76SERWZ893NVDMM10KX3NG3":3,"skill-same:01M76SERWZ893NVDMM10KX3NG3":52},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":25,"commitSha":26,"skillDirectory":27,"forksCount":14,"repositoryHtmlUrl":28,"repositoryHomepageUrl":6,"ownerHtmlUrl":29,"ownerBlogUrl":30,"ownerDescription":6,"updatedAt":31,"install":32,"resources":45},"01M76SERWZ893NVDMM10KX3NG3","test-smell-detection",null,"Deep-dive audit using the full testsmells.org 19-smell academic catalog for .NET tests. Every finding maps to a named, citable smell from the research literature (Assertion Roulette, Duplicate Assert, Constructor Initialization, Default Test, Mystery Guest, Eager Test, Sensitive Equality, Conditional Test Logic, Sleepy Test, Magic Number Test, etc.) with research-backed severity and integration-test calibration. Works with MSTest, xUnit, NUnit, TUnit. INVOKE THIS SKILL ONLY when the user explicitly asks for the testsmells.org \u002F 19-smell academic catalog, a research-backed smell taxonomy audit, citable smell names from the literature, or a catalog deep-dive beyond pragmatic anti-patterns. DO NOT USE FOR: any general or pragmatic test audit — \"audit my tests\", \"do a smell audit\", \"review test quality\", severity-ranked anti-pattern reviews — use test-anti-patterns (the umbrella audit skill); writing new tests (use writing-mstest-tests); running tests (use run-tests); framework migration (use migration skills).","weiflycc-cmd\u002Fskills","weiflycc-cmd","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F250846518?v=4","01M756C4PFGZJWKK04WFB9S5XF","威飛工作室","01M756C4QJJ66QDXN2RN6SXY87",0,"MIT","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet-test\u002Fskills\u002Ftest-smell-detection\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"---\nname: test-smell-detection\ndescription: >\n  Deep-dive audit using the full testsmells.org 19-smell academic catalog\n  for .NET tests. Every finding maps to a named, citable smell from the\n  research literature (Assertion Roulette, Duplicate Assert, Constructor\n  Initialization, Default Test, Mystery Guest, Eager Test, Sensitive\n  Equality, Conditional Test Logic, Sleepy Test, Magic Number Test, etc.)\n  with research-backed severity and integration-test calibration. Works\n  with MSTest, xUnit, NUnit, TUnit.\n  INVOKE THIS SKILL ONLY when the user explicitly asks for the\n  testsmells.org \u002F 19-smell academic catalog, a research-backed smell\n  taxonomy audit, citable smell names from the literature, or a catalog\n  deep-dive beyond pragmatic anti-patterns.\n  DO NOT USE FOR: any general or pragmatic test audit — \"audit my tests\",\n  \"do a smell audit\", \"review test quality\", severity-ranked anti-pattern\n  reviews — use test-anti-patterns (the umbrella audit skill); writing\n  new tests (use writing-mstest-tests); running tests (use run-tests);\n  framework migration (use migration skills).\nlicense: MIT\n---\n\n# Test Smell Detection\n\nDeep formal audit of test code 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## 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: 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 by looking for test framework markers — see the `dotnet-test-frameworks` skill for .NET-specific markers.\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 2: Scan for test smells\n\nFor each test method and class, check for the following smell categories:\n\n#### Smell 1: Conditional Test Logic\n\nTest methods containing `if`, `else`, `switch`, ternary (`? :`), `for`, `foreach`, or `while` statements. 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.\n**Exception:** `foreach` used solely to assert every item in a known collection is acceptable when the assertion is the loop body.\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.\n**Exception:** In-memory fakes or test-specific handlers 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**Detection:** Calls to sleep\u002Fdelay functions inside test methods. See the `dotnet-test-frameworks` skill for .NET-specific patterns.\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 (framework-specific: `Assert.*`, `expect()`, `assert`, `Should*`, etc.) and no expected-exception annotation.\n**Calibration:** A method named `*_DoesNotThrow` or `*_NoException` is implicitly asserting no exception — still flag it but note it may be intentional.\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 tests or workflow tests may legitimately call multiple methods — note this as a possible exception for end-to-end scenarios.\n\n#### Smell 6: Magic Number Test\n\nAssertions that contain unexplained numeric literals. The intent of `Assert.AreEqual(42, result)` 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.\n**Calibration:** Small integers in context (like count checks `Assert.AreEqual(3, list.Count)` 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 `ToString()` for comparison or assertion. If the `ToString()` implementation changes, the test breaks even though the actual behavior is correct.\n\n**Severity:** Medium\n**Detection:** `Assert.AreEqual(expected, obj.ToString())`, or `.ToString()` appearing inside an assertion parameter.\n\n#### Smell 8: Exception Handling in Tests\n\nTests that contain `try`\u002F`catch` blocks or `throw` statements. This typically means the test is manually managing exceptions rather than using the framework's built-in exception assertion facilities.\n\n**Severity:** Medium\n**Detection:** `try`\u002F`catch` or `throw`\u002F`raise` statements inside a test method.\n**Exception:** `catch` blocks that capture an exception for further assertion 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 or constructor 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 initialized in setup that are referenced by fewer than half the test methods in the class.\n\n#### Smell 10: Ignored\u002FDisabled 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\u002Fignore annotations or conditional compilation that disables a test. See the `dotnet-test-frameworks` skill for framework-specific skip attributes.\n\n### Step 3: Apply calibration rules\n\nBefore reporting, calibrate findings to avoid false positives:\n\n- **Integration tests have different norms.** A test class clearly marked as integration (by name, annotation, or category) legitimately uses external resources, calls multiple methods, and may use delays for async coordination. Downgrade Mystery Guest, Eager Test, and Sleepy Test severity for integration tests — note them but don't flag as problems.\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- **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- **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\u002Fcatch patterns that capture an exception then assert on its properties are ugly but functional. Note as a smell and suggest the framework's built-in exception assertion 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 4: 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 patterns that are appropriate for their scope\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 and adjust severity accordingly |\n| Flagging loop-over-collection-assert as conditional logic | Only flag loops with branching or complex logic, not assertion iterations |\n| Flagging obvious count assertions after adding N items | Consider the immediate context — self-documenting numbers are fine |\n| Missing framework-specific assertion syntax | Consult the `dotnet-test-frameworks` skill for .NET framework assertion and skip APIs |\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 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","# Test Smell Detection\n\nDeep formal audit of test code 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## 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: 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 by looking for test framework markers — see the `dotnet-test-frameworks` skill for .NET-specific markers.\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 2: Scan for test smells\n\nFor each test method and class, check for the following smell categories:\n\n#### Smell 1: Conditional Test Logic\n\nTest methods containing `if`, `else`, `switch`, ternary (`? :`), `for`, `foreach`, or `while` statements. 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.\n**Exception:** `foreach` used solely to assert every item in a known collection is acceptable when the assertion is the loop body.\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.\n**Exception:** In-memory fakes or test-specific handlers 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**Detection:** Calls to sleep\u002Fdelay functions inside test methods. See the `dotnet-test-frameworks` skill for .NET-specific patterns.\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 (framework-specific: `Assert.*`, `expect()`, `assert`, `Should*`, etc.) and no expected-exception annotation.\n**Calibration:** A method named `*_DoesNotThrow` or `*_NoException` is implicitly asserting no exception — still flag it but note it may be intentional.\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 tests or workflow tests may legitimately call multiple methods — note this as a possible exception for end-to-end scenarios.\n\n#### Smell 6: Magic Number Test\n\nAssertions that contain unexplained numeric literals. The intent of `Assert.AreEqual(42, result)` 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.\n**Calibration:** Small integers in context (like count checks `Assert.AreEqual(3, list.Count)` 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 `ToString()` for comparison or assertion. If the `ToString()` implementation changes, the test breaks even though the actual behavior is correct.\n\n**Severity:** Medium\n**Detection:** `Assert.AreEqual(expected, obj.ToString())`, or `.ToString()` appearing inside an assertion parameter.\n\n#### Smell 8: Exception Handling in Tests\n\nTests that contain `try`\u002F`catch` blocks or `throw` statements. This typically means the test is manually managing exceptions rather than using the framework's built-in exception assertion facilities.\n\n**Severity:** Medium\n**Detection:** `try`\u002F`catch` or `throw`\u002F`raise` statements inside a test method.\n**Exception:** `catch` blocks that capture an exception for further assertion 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 or constructor 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 initialized in setup that are referenced by fewer than half the test methods in the class.\n\n#### Smell 10: Ignored\u002FDisabled 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\u002Fignore annotations or conditional compilation that disables a test. See the `dotnet-test-frameworks` skill for framework-specific skip attributes.\n\n### Step 3: Apply calibration rules\n\nBefore reporting, calibrate findings to avoid false positives:\n\n- **Integration tests have different norms.** A test class clearly marked as integration (by name, annotation, or category) legitimately uses external resources, calls multiple methods, and may use delays for async coordination. Downgrade Mystery Guest, Eager Test, and Sleepy Test severity for integration tests — note them but don't flag as problems.\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- **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- **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\u002Fcatch patterns that capture an exception then assert on its properties are ugly but functional. Note as a smell and suggest the framework's built-in exception assertion 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 4: 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 patterns that are appropriate for their scope\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 and adjust severity accordingly |\n| Flagging loop-over-collection-assert as conditional logic | Only flag loops with branching or complex logic, not assertion iterations |\n| Flagging obvious count assertions after adding N items | Consider the immediate context — self-documenting numbers are fine |\n| Missing framework-specific assertion syntax | Consult the `dotnet-test-frameworks` skill for .NET framework assertion and skip APIs |\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 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",{"name":5,"license":15,"description":24},"Deep-dive audit using the full testsmells.org 19-smell academic catalog for .NET tests. Every finding maps to a named, citable smell from the research literature (Assertion Roulette, Duplicate Assert, Constructor Initialization, Default Test, Mystery Guest, Eager Test, Sensitive Equality, Conditional Test Logic, Sleepy Test, Magic Number Test, etc.) with research-backed severity and integration-test calibration. Works with MSTest, xUnit, NUnit, TUnit. INVOKE THIS SKILL ONLY when the user explicitly asks for the testsmells.org \u002F 19-smell academic catalog, a research-backed smell taxonomy audit, citable smell names from the literature, or a catalog deep-dive beyond pragmatic anti-patterns. DO NOT USE FOR: any general or pragmatic test audit — \"audit my tests\", \"do a smell audit\", \"review test quality\", severity-ranked anti-pattern reviews — use test-anti-patterns (the umbrella audit skill); writing new tests (use writing-mstest-tests); running tests (use run-tests); framework migration (use migration skills).\n","main","5810d492c9b301d8227f932bf87b5c954c4fa4d6","plugins\u002Fdotnet-test\u002Fskills\u002Ftest-smell-detection","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd","weiflycc.com","2026-11-10 03:26:55",{"source":8,"skillName":5,"commands":33,"prompt":43,"zipAvailable":44},[34,37,40],{"tool":35,"command":36},"npx","npx skills add weiflycc-cmd\u002Fskills --skill test-smell-detection",{"tool":38,"command":39},"bunx","bunx skills add weiflycc-cmd\u002Fskills --skill test-smell-detection",{"tool":41,"command":42},"pnpm","pnpm dlx skills add weiflycc-cmd\u002Fskills --skill test-smell-detection","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet-test\u002Fskills\u002Ftest-smell-detection\u002FSKILL.md",true,[46],{"path":47,"resourceType":48,"resourceTypeDesc":49,"sizeBytes":50,"sourceHtmlUrl":51},"references\u002Ftest-smell-catalog.md","REFERENCE","参考文档",5953,"https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet-test\u002Fskills\u002Ftest-smell-detection\u002Freferences\u002Ftest-smell-catalog.md",[53,60,67,74,81,88],{"skillNo":54,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":57,"categories":58,"keywords":59,"publishedAt":19},"01M76SGT4WG5682JQJ0V3NSK6X","system-text-json-net11","Provides guidance on new System.Text.Json APIs introduced in .NET 11. It covers typed JsonTypeInfo access via GetTypeInfo\u003CT> and TryGetTypeInfo\u003CT> on JsonSerializerOptions, and the new JsonNamingPolicy.PascalCase static property. Use when serializing or deserializing JSON in .NET 11 applications and needing typed metadata access or PascalCase property naming.","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet11\u002Fskills\u002Fsystem-text-json-net11\u002FSKILL.md",[],[],{"skillNo":61,"name":62,"nameZh":6,"description":63,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":19},"01M76SGPNZYYV9BCZJW7BF7J8A","nuget-trusted-publishing","Set up NuGet trusted publishing (OIDC) on a GitHub Actions repo — replaces long-lived API keys with short-lived tokens. USE FOR: trusted publishing, NuGet OIDC, keyless NuGet publish, migrate from NuGet API key, NuGet\u002Flogin, secure NuGet publishing. DO NOT USE FOR: publishing to private feeds or Azure Artifacts (OIDC is nuget.org only). INVOKES: shell (powershell or bash), edit, create, ask_user for guided repo setup.","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet\u002Fskills\u002Fnuget-trusted-publishing\u002FSKILL.md",[],[],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":73,"publishedAt":19},"01M76SGHVNBNVM1DMVDYTMAE5G","dotnet-pinvoke","Correctly call native (C\u002FC++) libraries from .NET using P\u002FInvoke and LibraryImport. Covers function signatures, string marshalling, memory lifetime, SafeHandle, and cross-platform patterns. USE FOR: writing new P\u002FInvoke or LibraryImport declarations, reviewing or debugging existing native interop code, wrapping a C or C++ library for use in .NET, diagnosing crashes, memory leaks, or corruption at the managed\u002Fnative boundary. DO NOT USE FOR: COM interop, C++\u002FCLI mixed-mode assemblies, or pure managed code with no native dependencies.","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet\u002Fskills\u002Fdotnet-pinvoke\u002FSKILL.md",[],[],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":19},"01M76SGDB9Z3GSB1CFW314NC84","csharp-scripts","Run file-based C# apps with the .NET CLI when the user explicitly wants C#\u002F.NET code without creating a project. Use for C# language\u002FAPI experiments, one-file C# apps, small multi-file C# apps composed with `#:include`\u002F`#:exclude`, or C# file-based apps linked with `#:ref`. Do not use for language-agnostic throwaway scripts, generic computations, Python\u002FPowerShell-style automation, full projects, or existing app integration.","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet\u002Fskills\u002Fcsharp-scripts\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":19},"01M76SG805T8W764WAKB1NP3CJ","thread-abort-migration","Guides migration of .NET Framework Thread.Abort usage to cooperative cancellation in modern .NET. USE FOR: modernizing code that calls Thread.Abort, catching ThreadAbortException, replacing Thread.ResetAbort, replacing Thread.Interrupt for thread termination, resolving PlatformNotSupportedException or SYSLIB0006 after retargeting to .NET 6+, migrating ASP.NET Response.End or Response.Redirect(url, true) which internally call Thread.Abort. DO NOT USE FOR: code that only uses Thread.Join, Thread.Sleep, or Thread.Start without any abort, interrupt, or ThreadAbortException usage — these APIs work identically in modern .NET and need no migration. Also not for projects staying on .NET Framework, or Thread.Abort usage inside third-party libraries you do not control.","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet-upgrade\u002Fskills\u002Fthread-abort-migration\u002FSKILL.md",[],[],{"skillNo":89,"name":90,"nameZh":6,"description":91,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":92,"categories":93,"keywords":94,"publishedAt":19},"01M76SG2588ZJBE5C51HYJJSKV","migrate-nullable-references","Enable nullable reference types in a C# project and systematically resolve all warnings. USE FOR: adopting NRTs in existing codebases, file-by-file or project-wide migration, fixing CS8602\u002FCS8618\u002FCS86xx warnings, annotating APIs for nullability, cleaning up null-forgiving operators, upgrading dependencies with new nullable annotations. DO NOT USE FOR: projects already fully migrated with zero warnings (unless auditing suppressions), fixing a handful of nullable warnings in code that already has NRTs enabled, suppressing warnings without fixing them, C# 7.3 or earlier projects. INVOKES: Get-NullableReadiness.ps1 scanner script.","https:\u002F\u002Fgithub.com\u002Fweiflycc-cmd\u002Fskills\u002Fblob\u002Fmain\u002Fplugins\u002Fdotnet-upgrade\u002Fskills\u002Fmigrate-nullable-references\u002FSKILL.md",[],[]]