Gemini 2.5 Flash × go-test

Okay, here's the Go test file (`wordcount_test.go`) along with a basic implementation of the `WordCount` function (`wordcount.go`) so the test can compile and run.

First, create a file named `wordcount.go` in a directory named `wordcount`:

```go
// wordcount/wordcount.go
package wordcount

import (
	"regexp"
	"strings"
)

// 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 {
	counts := make(map[string]int)

	// Convert the entire string to lowercase first to handle case-insensitivity.
	s = strings.ToLower(s)

	// Use a regular expression to find sequences of letters.
	// This regex `[a-z]+` effectively treats any non-letter character
	// (like whitespace, punctuation, numbers, symbols) as a word separator
	// and strips them from the words themselves.
	re := regexp.MustCompile(`[a-z]+`)
	words := re.FindAllString(s, -1) // Find all non-overlapping matches

	for _, word := range words {
		// The regex already ensures words are pure letter sequences.
		// A final check `if word != ""` prevents potential empty strings
		// from being processed, though for `[a-z]+`, it's generally not needed.
		if word != "" {
			counts[word]++
		}
	}
	return counts
}
```

Next, create the test file `wordcount_test.go` in the same directory:

```go
// wordcount/wordcount_test.go
package wordcount

import (
	"maps"    // Requires Go 1.21+ for maps.Equal. Use reflect.DeepEqual for older versions.
	"reflect" // Used for reflect.DeepEqual if maps.Equal is not available
	"testing"
)

// TestWordCount tests the WordCount function using a table-driven approach.
func TestWordCount(t *testing.T) {
	// Define test cases as a slice of structs.
	var tests = []struct {
		name  string           // Name of the test case
		input string           // Input string to WordCount
		want  map[string]int   // Expected output map
	}{
		{
			name:  "Empty string",
			input: "",
			want:  map[string]int{},
		},
		{
			name:  "Single word",
			input: "hello",
			want:  map[string]int{"hello": 1},
		},
		{
			name:  "Mixed case words",
			input: "Hello hello HELLO",
			want:  map[string]int{"hello": 3},
		},
		{
			name:  "Punctuation attached to words",
			input: "Hello, world! How are you?",
			want:  map[string]int{"hello": 1, "world": 1, "how": 1, "are": 1, "you": 1},
		},
		{
			name:  "Repeated words",
			input: "apple banana apple orange banana apple",
			want:  map[string]int{"apple": 3, "banana": 2, "orange": 1},
		},
		{
			name:  "Multi-word sentence",
			input: "This is a test. A good test it is, indeed!",
			want:  map[string]int{"this": 1, "is": 2, "a": 2, "test": 2, "good": 1, "it": 1, "indeed": 1},
		},
		{
			name:  "Words with numbers and hyphens (punctuation stripping)",
			input: "word123 another-word 456 test-case",
			// Based on the regex `[a-z]+`, numbers and hyphens are treated as separators/stripped.
			// "word123" -> "word"
			// "another-word" -> "another", "word"
			// "456" -> "" (no letters)
			// "test-case" -> "test", "case"
			want: map[string]int{"word": 2, "another": 1, "test": 1, "case": 1},
		},
		{
			name:  "Leading/trailing and multiple internal whitespace",
			input: "  \t  hello   world   \n  again  ",
			want:  map[string]int{"hello": 1, "world": 1, "again": 1},
		},
		{
			name:  "Sentence with various punctuation and multiple occurrences",
			input: "  Go is a great language! It's fast, concise, and fun. (Go, go, go!)  ",
			want:  map[string]int{"go": 4, "is": 1, "a": 1, "great": 1, "language": 1, "it": 1, "fast": 1, "concise": 1, "and": 1, "fun": 1},
		},
	}

	for _, tc := range tests {
		// Use t.Run for subtests to make test failures identifiable by name.
		t.Run(tc.name, func(t *testing.T) {
			got := WordCount(tc.input)

			// Compare the resulting maps with the expected map.
			// For Go 1.21 and later, maps.Equal is the preferred way.
			if !maps.Equal(got, tc.want) {
			// For Go versions prior to 1.21, use reflect.DeepEqual:
			// if !reflect.DeepEqual(got, tc.want) {
				t.Errorf("WordCount(%q)\n  got: %v\n expected: %v", tc.input, got, tc.want)
			}
		})
	}
}

// BenchmarkWordCount measures the performance of the WordCount function
// on a realistic, moderately long sentence/paragraph.
func BenchmarkWordCount(b *testing.B) {
	// A reasonably long and complex sentence for a realistic benchmark.
	realisticSentence := "The quick brown fox jumps over the lazy dog. This is a classic pangram, often used to display " +
		"font samples or to test typewriters and computer keyboards. It contains every letter of the " +
		"English alphabet at least once. Punctuation, capitalization, and numbers should be handled " +
		"correctly by the WordCount function. For instance, 'fox,' and 'fox' should count as the same word. " +
		"Let's see how many words are in this paragraph. There are quite a few, indeed! It's an excellent " +
		"example for benchmarking purposes, showcasing various aspects like repeated words, mixed case, " +
		"and punctuation stripping in a natural language context. Performance matters here, especially " +
		"for text processing tasks. What do you think about this benchmark sentence?"

	// Reset timer to exclude any setup time (though minimal here).
	b.ResetTimer()

	// Run the WordCount function b.N times.
	for i := 0; i < b.N; i++ {
		WordCount(realisticSentence)
	}
}
```

### To run these tests and benchmarks:

1.  **Create a directory structure:**
    ```
    myproject/
    └── wordcount/
        ├── wordcount.go
        └── wordcount_test.go
    ```
2.  **Navigate to the `wordcount` directory** in your terminal.
3.  **Run tests:**
    ```bash
    go test
    ```
    This will execute `TestWordCount` and its subtests.
4.  **Run benchmarks:**
    ```bash
    go test -bench=.
    ```
    This will execute `BenchmarkWordCount` and report its performance.
5.  **Run specific test/benchmark:**
    ```bash
    go test -run='TestWordCount/Punctuation attached to words'
    go test -bench='BenchmarkWordCount'
    ```