Language-specific guidance: Call the

test-analysis-extensions

skill to discover available extension files, then read the file matching the target codebase's language and framework (e.g.,

extensions/dotnet.md

,

extensions/python.md

,

extensions/typescript.md

,

extensions/go.md

). You MUST read the relevant extension file before scoring assertions or anti-patterns, because assertion APIs and idiomatic patterns differ significantly across frameworks.

• A PR automation workflow needs to post a comment grading the tests introduced or modified in a pull request.
• A reviewer has a specific list of tests (a file, a class, a method list, or a diff hunk) and wants a per-test verdict rather than a suite report.
• A maintainer wants to triage which of N tests in a contribution deserve follow-up improvements.

• The caller wants a full suite audit or comparative metrics — use

  test-anti-patterns

  (pragmatic) or

  test-smell-detection

  (formal) and let the

  test-quality-auditor

  agent orchestrate.
• The caller wants to write new tests — use

  code-testing-generator

  (any language) or

  writing-mstest-tests

  (MSTest specifically).
• The caller wants to measure code coverage or CRAP scores — use

  coverage-analysis

  or

  crap-score

  (.NET only).
• The caller wants to fix issues directly in test code — invoke the appropriate editing skill.
• No specific list of tests is provided. Do not try to grade every test in the workspace; ask the caller for an explicit list or scope.

1. An explicit list of test method names, or
2. One or more file paths plus an explicit instruction to grade every test declared in those files (e.g., "grade every test in

   OrderTests.cs

   "), or
3. A diff hunk or PR identifier whose changed tests should be graded.

test-quality-auditor

test-anti-patterns

1. If the test body is provided inline, use it directly.
2. Otherwise read the file at the given path and locate the method by its fully-qualified name. Capture the full method body, including attributes / decorators / fixtures and any helper code that the test calls.
3. If a method cannot be found, record it as

   N/A — method not found

   and continue. Never invent a body to grade.

1. Hard ceiling pass. Every Critical or High finding sets a maximum sub-grade (F, D, or C as labeled). Take the worst ceiling across all matched Critical/High findings — these do not accumulate (a single F finding caps the sub-grade at F regardless of how many other Critical/High findings are present).
2. Medium-deduction pass. Start from A, then for each Medium finding deduct one sub-grade level (A→B, B→C, C→D, D→F). These do accumulate across findings.

min(hard_ceiling, A − medium_count)

• Zero Critical/High, 1 Medium → B (A − 1)
• Zero Critical/High, 3 Medium → D (A − 3)
• One C-ceiling (e.g., over-mocking), 0 Medium → C
• One C-ceiling, 2 Medium → D (

  min(C, A − 2 = C) = C

  , but a third Medium would tip to D)
• One F-finding (e.g., swallowed exception) plus any number of Medium → F

• No assertions at all → F (also drives Assertion sub-grade to F)
• Swallowed exceptions:

  try { … } catch { }

  (.NET), bare

  except: pass

  (Python),

  try { … } catch (e) {}

  (JS/TS/Java),

  defer recover()

  without re-panic (Go),

  rescue StandardError

  with no assertion (Ruby), empty

  catch

  (Kotlin/Swift) → F
• Assert-in-catch pattern (

  Assert.Fail(ex.Message)

  instead of

  Assert.ThrowsException

  ) → D
• Always-true literal assertions (

  Assert.IsTrue(true)

  ,

  assert True

  ,

  expect(true).toBe(true)

  ) → F (verifies nothing; also drives Assertion sub-grade to F)
• Self-referential / tautological assertions on bound values (

  Assert.AreEqual(x, x)

  ,

  assert dto.name == dto.name

  ) → D
• Commented-out assertions → D

• Wall-clock sleep used for synchronization:

  Thread.Sleep

  ,

  Task.Delay

  ,

  time.sleep

  ,

  setTimeout

  -based wait,

  Thread.sleep

  ,

  time.Sleep

  ,

  sleep

  ,

  std::thread::sleep

  ,

  Start-Sleep

  ,

  std::this_thread::sleep_for

  (in a unit test) → D
• Unseeded randomness, wall-clock reads without abstraction (

  DateTime.Now

  ,

  datetime.now()

  ,

  Date.now()

  ,

  System.currentTimeMillis()

  ,

  time.Now()

  ,

  Time.now

  ,

  Instant::now()

  ,

  Get-Date

  ,

  system_clock::now

  ) → D
• Hard-coded environment-dependent paths (

  C:\…

  ,

  /tmp/…

  , network hosts) → D
• Ordering dependency on mutable static / package globals → D
• Broad exception assertion (

  Assert.ThrowsException<Exception>

  ,

  pytest.raises(Exception)

  ,

  expect(fn).toThrow(Error)

  without matcher,

  #[should_panic]

  without

  expected = "…"

  ,

  Should -Throw

  without

  -ExpectedMessage

  ,

  EXPECT_ANY_THROW

  ) → C
• Over-mocking: more mock setup lines than test logic, or verifying exact call sequences instead of outcomes → C
• Implementation coupling: reflection on private members, casting to internal types to access state → C

• Poor name:

  Test1

  ,

  TestMethod

  ,

  test

  , single-word name that says nothing about scenario or expected outcome (judge against the language extension's convention) → drop one sub-grade
• Magic values: unexplained

  42

  ,

  "foo"

  ,

  0x1234

  in arrange/assert without naming or comment → drop one sub-grade
• Giant test (>30 lines covering a single behavior) → drop one sub-grade
• Assertion messages that just repeat the assertion text → drop one sub-grade
• Missing AAA / GWT separation when the test is non-trivial → drop one sub-grade

• Unused setup/teardown hooks; print debugging left in (

  Console.WriteLine

  ,

  print

  ,

  console.log

  ,

  System.out.println

  ,

  fmt.Println

  ,

  puts

  ,

  dbg!

  ,

  Write-Host

  ,

  std::cout

  ); inconsistent naming versus siblings; leftover TODO comments. Mention in the note column but do not deduct.

• Overall score band = weighted average:

  0.45 × Assertion + 0.30 × Anti-pattern + 0.25 × Structure

• Map to letter:
  • ≥ 3.5 → A (band 90–100)
  • ≥ 2.8 → B (band 80–89)
  • ≥ 2.0 → C (band 70–79)
  • ≥ 1.2 → D (band 60–69)
  • < 1.2 → F (band 0–59)
• The overall grade is capped at the worst sub-grade — if any sub-grade is F, the overall grade is F; if the worst sub-grade is D, the overall grade is at most D; and so on. A test that fails on any one dimension cannot earn a higher overall grade than that dimension.

• A (90–100):

  Clear AAA structure; equality + exception assertions on the public contract.

• B (80–89):

  Good assertion variety, mildly long body — consider splitting into per-condition tests.

• C (70–79):

  Only checks IsNotNull on the result; no value verification.

• D (60–69):

  Self-referential assertion: round-trip identity verifies plumbing, not transformation.

• F (0–59):

  No assertions — test executes the method but never verifies anything.

No issues found.

| Test | Grade | Band | Notes |
|------|-------|------|-------|
| `Namespace.ClassName.Test_Method_Condition_Expected` | A | 90–100 | Clear AAA; equality + exception assertions. |
| `Namespace.ClassName.Test_Other` | C | 70–79 | Only `IsNotNull` — no value verification. |
| `Namespace.ClassName.Test_Old` | F | 0–59 | No assertions. |

• If the table would exceed 50 rows, show all tests graded below B first (worst to best), then a sample of the best tests, and wrap any overflow in a collapsed

  <details>

  block.
• Within the same grade, order by file path then by method name for determinism.
• If the diff context is provided, prefix each test name with a

  (new)

  or

  (modified)

  marker.

• Every test in the input list appears in the table (or is recorded as

  N/A — method not found

  ).
• Every grade is justified by at least one observable signal in the captured body — no speculative deductions.
• Trivial-assertion tests are flagged only when the only assertion is trivial (a null check before a meaningful assertion is not trivial).
• Exception-only tests are not penalized for low assertion count.
• Mock-call verifications and bare assertion forms count as real assertions of the appropriate category.
• Boolean assertions on meaningful properties (

  Assert.IsTrue(result.IsValid)

  ) are not classified as always-true; only literal

  true

  /

  false

  constants are.
• Self-referential assertions are flagged separately from normal equality assertions.
• Idiomatic patterns are not flagged: Go/Rust table-driven sub-tests, pytest bare

  assert

  , Go

  if got != want { t.Errorf(...) }

  , JS/TS

  expect(mock).toHaveBeenCalledWith(...)

  .
• Async test pitfalls (un-awaited

  resolves

  /

  rejects

  /

  ThrowsAsync

  , pytest-asyncio without

  await

  ) drop the Assertion sub-grade to F.
• The summary leads with the highest-leverage observation, not a recap of the table.