mock: fix data race in Arguments.Diff for pointer-like arguments

[pavelzeman]

Summary

Fixes Arguments.Diff causing data races when mock arguments (pointers, maps, slices) are concurrently modified by other goroutines.

Problem

Arguments.Diff uses fmt.Sprintf("%v") to format arguments for diff output. This traverses the underlying data structure, which races with concurrent writers:

• Maps: triggers fatal error: concurrent map iteration and map write — crashes the entire test process (non-recoverable by recover())
• Pointers/slices: causes data races detectable by go test -race

This is a real-world issue. For example, Mattermost hit this with *sql.DB arguments — the database connection cleaner goroutine modifies internal fields while testify formats the struct for diff output.

Solution

Introduces safeFormatArg() with targeted handling per kind:

Kind	Strategy	Rationale
Map	%p (address only)	Map iteration is fatally unsafe with concurrent writes — no recovery possible
Ptr, Slice	%v with panic recovery → %p fallback	Races produce recoverable panics; preserves full output when safe
Everything else	%v (unchanged)	Value types cannot race

This preserves the full %v diff output for the common case (non-concurrent arguments, value types, pointers/slices without active races) while preventing testify from being the source of data races or fatal crashes.

Tests

Three new race-condition tests:

1. Test_Arguments_Diff_ConcurrentPointerModification — adapted from mock: avoid data races in Arguments.Diff #1598, pointer struct modified by another goroutine
2. Test_Arguments_Diff_ConcurrentMapModification — raised by @brackendawson in mock: avoid data races in Arguments.Diff #1598 review, map modified by another goroutine
3. Test_Arguments_Diff_ConcurrentSliceModification — slice modified by another goroutine

All three crash/race without the fix and pass cleanly with it.

Alternatives Considered

• mock: avoid data races in Arguments.Diff #1598: Uses %p for all reflect.Ptr kinds. Doesn't cover maps (fatal) or slices. Loses diff output even when arguments aren't being concurrently modified.
• Deep-copy at capture time: copyArgument() itself races for maps (iterating to copy triggers the same fatal error). Would require external synchronization that testify can't enforce.
• Deep-copy in MethodCalled: Same map iteration problem, plus significant performance overhead for every mock call.

Related

Fixes #1597
Related to #1598 (alternative approach, open since 2024)