Claude Sonnet 4.6 × go-test

```go
package wordcount_test

import (
	"reflect"
	"testing"
)

// WordCount returns a map of each unique word in s to the number
// of times it appears. Words are case-insensitive and separated by
// whitespace. Punctuation attached to words is stripped.
func WordCount(s string) map[string]int {
	// Placeholder implementation for compilation purposes.
	// Replace with the actual implementation or import it from the package.
	return nil
}

func TestWordCount(t *testing.T) {
	testCases := []struct {
		name  string
		input string
		want  map[string]int
	}{
		{
			name:  "empty string",
			input: "",
			want:  map[string]int{},
		},
		{
			name:  "single word",
			input: "hello",
			want:  map[string]int{"hello": 1},
		},
		{
			name:  "mixed case",
			input: "Go go GO",
			want:  map[string]int{"go": 3},
		},
		{
			name:  "punctuation stripped",
			input: "hello, world!",
			want:  map[string]int{"hello": 1, "world": 1},
		},
		{
			name:  "repeated words",
			input: "the cat sat on the mat the cat",
			want:  map[string]int{"the": 3, "cat": 2, "sat": 1, "on": 1, "mat": 1},
		},
		{
			name:  "multi-word sentence",
			input: "to be or not to be that is the question",
			want: map[string]int{
				"to":       2,
				"be":       2,
				"or":       1,
				"not":      1,
				"that":     1,
				"is":       1,
				"the":      1,
				"question": 1,
			},
		},
		{
			name:  "leading and trailing whitespace",
			input: "  spaces everywhere  ",
			want:  map[string]int{"spaces": 1, "everywhere": 1},
		},
		{
			name:  "multiple spaces between words",
			input: "one   two   three",
			want:  map[string]int{"one": 1, "two": 1, "three": 1},
		},
		{
			name:  "numbers treated as words",
			input: "1 2 3 1 2",
			want:  map[string]int{"1": 2, "2": 2, "3": 1},
		},
		{
			name:  "mixed punctuation and case",
			input: "It's a trap! IT'S A TRAP!",
			want:  map[string]int{"its": 2, "a": 2, "trap": 2},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			got := WordCount(tc.input)

			// Handle nil vs empty map comparison gracefully.
			if got == nil && len(tc.want) == 0 {
				return
			}

			if !reflect.DeepEqual(got, tc.want) {
				t.Errorf("WordCount(%q)\n  got:  %v\n  want: %v", tc.input, got, tc.want)
			}
		})
	}
}

// BenchmarkWordCount measures the performance of WordCount on a realistic
// multi-sentence paragraph to simulate real-world usage.
func BenchmarkWordCount(b *testing.B) {
	input := "The quick brown fox jumps over the lazy dog. " +
		"A fox is quick and the dog is lazy. " +
		"Jumps, leaps, and bounds are all ways a fox can move. " +
		"The dog watched the fox jump over it again and again."

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		WordCount(input)
	}
}
```

---

### Notes on the test file

| Aspect | Decision |
|---|---|
| **Package** | `wordcount_test` (external test package) so it tests the public API without circular imports. |
| **Imports** | Only `reflect` and `testing` — no third-party libraries. |
| **Map comparison** | `reflect.DeepEqual` is used; a `nil` vs. empty-map guard handles implementations that return `nil` for empty input. |
| **Subtests** | Every case runs via `t.Run(tc.name, ...)` so `go test -run TestWordCount/mixed_case` works. |
| **Placeholder** | The stub `WordCount` at the top compiles the file standalone. Delete it and use a proper `import` or place the real implementation in `wordcount.go` in the same package before running. |
| **Benchmark** | Uses a multi-sentence paragraph (~40 tokens) to give a realistic signal; `b.ResetTimer()` is called after any setup. |

To run:

```bash
# Tests
go test ./...

# Verbose with subtest names
go test -v -run TestWordCount ./...

# Benchmark
go test -bench=BenchmarkWordCount -benchmem ./...
```