Answer

SOLUTION

The mock was doing O(N) work per List call: cloning every fixture struct into a fresh []*Incident (N struct copies + N-pointer slice) and re-sorting the whole thing, every call. For 10k fixtures that's ~722KB/op of garbage → GC churn → p95 spikes. The fix has three parts.

1. Sort []*T pointers once, at construction; copy only the page per call (incident.go):

type SortedPointerRepository struct {
    fixtures []*Incident // sorted once; shared read-only afterwards
}

func NewSortedPointerRepository(fixtures []Incident) *SortedPointerRepository {
    ptrs := make([]*Incident, len(fixtures))
    for i := range fixtures {
        f := fixtures[i]
        ptrs[i] = &f
    }
    sort.Slice(ptrs, func(i, j int) bool { return less(ptrs[i], ptrs[j]) }) // 8-byte moves, once
    return &SortedPointerRepository{fixtures: ptrs}
}

func (r *SortedPointerRepository) List(_ context.Context, page, pageSize int) ([]*Incident, error) {
    start := page * pageSize
    if start >= len(r.fixtures) {
        return []*Incident{}, nil
    }
    end := start + pageSize
    if end > len(r.fixtures) {
        end = len(r.fixtures)
    }
    out := make([]*Incident, end-start) // copy ONLY the page's pointers
    copy(out, r.fixtures[start:end])
    return out, nil
}

The page slice is still fresh (defensive against caller mutation of the slice header), but allocation is now O(pageSize), not O(N).

2. Benchmarks measure the handler, not the mock (bench_test.go): inject the mock into NewIncidentHandler and benchmark h.List(...) — the end-to-end path with a realistic page size, rotating pages so the benchmark isn't hitting one hot slice:

func BenchmarkIncidentHandlerList_EndToEnd(b *testing.B) {
    h := NewIncidentHandler(NewSortedPointerRepository(makeFixtures(10000)))
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        if _, err := h.List(context.Background(), i%10, 20); err != nil {
            b.Fatal(err)
        }
    }
}

3. Profile the real benchmark suite, not unit tests — mock/timer-driven unit tests complete in microseconds and yield zero CPU samples:

go test -bench=. -benchmem -run=^$ -cpuprofile cpu.prof .
go tool pprof -top cpu.prof

Gotcha verified against $GOROOT/src/testing/match.go: -bench splits on /; a slash-less regex matches only the root benchmark name, so to profile one sub-benchmark you must pass the parent path: -bench='EndToEnd/handler_with_fixed_mock' (bare fixed_mock silently matches nothing).

EVIDENCE

All verified locally (Go 1.26, AMD Ryzen 7), 10,000 fixtures, page 20:

• Mock List: ~7,000× faster, ~4,500× fewer bytes, 10,004 → 1 alloc. The 824KB/op report is reproduced (722KB here) and eliminated.
• End-to-end: ~1,000× faster. The mock's share of handler cost dropped from ~100% to ~12% (62ns of 501ns), so the benchmark now genuinely measures handler DTO mapping.

Profiles: - Unit-test profile (go test -cpuprofile): Total samples = 0 — confirms mock/timer suites give zero CPU samples. - Full benchmark profile: 7900ms of samples; DeepCopyRepository.List at 24.8% cumulative with GC allocator frames (mallocgc, bulkBarrierPreWrite, scanObject) dominating — the GC-driven p95 hypothesis confirmed. - Fixed-mock benchmark profile: IncidentHandler.List at 61% cumulative; mock gone from the top nodes.

Tests (4, all passing): 1. TestFixedListPaginationAndOrder — 100 fixtures / page 10 → exactly 10 pages, 100 items, every page in canonical order. 2. TestFixedListEdgeCases — out-of-range page, pageSize=0, partial last page, empty fixture set (no panics). 3. TestPageCopyIsDefensive — replacing/appending to a returned page doesn't corrupt the repo's fixture slice. (Contract note: the slice is fresh, but pointed-to fixtures are shared read-only state — that's inherent to "copy only the page"; struct-level isolation is the deep-copy behavior we're removing.) 4. TestSortedMatchesDeepCopy — fixed repo produces byte-identical ordering to the old implementation (incl. tie-break on UpdatedAt → ID).

SIGNATURES

{"problem_class":"go-benchmark-mock-fullcopy-sort","model":"deepseek-v4-flash","result":"passed","tests":4}