Test Analysis Extensions

Go Test Framework Reference (testing package, testify)

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

Capability tags

Test File Identification

Test packages may be foo (white-box) or foo_test (black-box). The latter only sees exported names.

Assertion APIs

Go's testing package has no built-in assertion library. Tests fail by calling t.Error* / t.Fatal*.

require vs assert (testify): require.* calls t.FailNow() and stops the test; assert.* records the failure and continues. Tests that need preconditions before further work should use require.NoError(t, err).

Bare if ... { t.Error... } is the canonical Go assertion form. Do NOT flag these as missing-framework-API smells.

Other libraries: gotest.tools/v3 (assert.Check, assert.Equal), go-cmp (cmp.Diff).

Sleep/Delay Patterns

Skip/Ignore Annotations

There is no @Disabled-style permanent disable. Build tags and skip guards are the idiomatic way to gate tests.

Exception Handling — Idiomatic Alternatives

Go uses error returns and panics; there is no try/catch. Testing patterns:

// Error return:
if _, err := svc.PlaceOrder(empty); err == nil {
    t.Error("expected error, got nil")
}
// Better with testify:
_, err := svc.PlaceOrder(empty)
require.Error(t, err)
assert.Contains(t, err.Error(), "at least one item")

// Error-target match (Go 1.13+):
assert.ErrorIs(t, err, ErrEmptyOrder)
assert.ErrorAs(t, err, &validationErr)

// Panic:
assert.PanicsWithValue(t, "bad input", func() { mustParse("xxx") })

Flag tests that ignore returned errors (_, _ = svc.Foo()) without subsequent assertion.

Mystery Guest — Common Go Patterns

Integration Test Markers

• Build tag at file top: //go:build integration / //go:build e2e (run via go test -tags=integration)

• File name suffix: *_integration_test.go, *_e2e_test.go

• Package directory: tests/integration/, internal/integrationtests/

• testing.Short() guard pattern: if testing.Short() { t.Skip("integration test") }

Setup/Teardown

Tag/Trait Attributes (for test-tagging)

Default mode: report-only. Go has no per-test tag attribute. Strategies:

• Build tags scope an entire file (coarse): //go:build integration

• Subtest names can encode tags: t.Run("[positive] valid input returns ok", ...)

• Test name prefixes: func TestNegative_InvalidInput_Returns400

• testify suites with grouping methods

When the project already follows one of these conventions, switch to auto-edit mode and apply it consistently.

Language-specific calibration notes

• Table-driven tests with for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { ... }) } are idiomatic — do NOT flag the for loop as Conditional Test Logic.

• Bare if … t.Errorf patterns are the canonical assertion form. Do NOT flag as "no framework API used."

• Goroutine leaks in tests are a real smell — recommend goleak.VerifyNone(t) or t.Cleanup.

• t.Parallel() in tests: races on shared fixture data are a smell; tests calling t.Setenv then t.Parallel will fail in newer Go versions.

• require vs assert mixing: subsequent code after a failed assert.* may panic on nil. Prefer require.* for preconditions.

• Examples with // Output: are tests; treat the // Output: block as the assertion.

• Fuzz tests without f.Add(...) seed inputs may only run with -fuzz; flag as a coverage gap.

• Generated mocks (mockery, mockgen) — verify call expectations count as assertions.

• Missing t.Helper() in helper functions is not a smell per se but degrades failure location reporting.