1# Testing and Benchmarking
2 
3## Table-Driven Tests
4 
5```go
6package math
7 
8import "testing"
9 
10func Add(a, b int) int {
11    return a + b
12}
13 
14func TestAdd(t *testing.T) {
15    tests := []struct {
16        name     string
17        a, b     int
18        expected int
19    }{
20        {"positive numbers", 2, 3, 5},
21        {"negative numbers", -2, -3, -5},
22        {"mixed signs", -2, 3, 1},
23        {"zeros", 0, 0, 0},
24        {"large numbers", 1000000, 2000000, 3000000},
25    }
26 
27    for _, tt := range tests {
28        t.Run(tt.name, func(t *testing.T) {
29            result := Add(tt.a, tt.b)
30            if result != tt.expected {
31                t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
32            }
33        })
34    }
35}
36```
37 
38## Subtests and Parallel Execution
39 
40```go
41func TestParallel(t *testing.T) {
42    tests := []struct {
43        name  string
44        input string
45        want  string
46    }{
47        {"lowercase", "hello", "HELLO"},
48        {"uppercase", "WORLD", "WORLD"},
49        {"mixed", "HeLLo", "HELLO"},
50    }
51 
52    for _, tt := range tests {
53        tt := tt // Capture range variable for parallel tests
54        t.Run(tt.name, func(t *testing.T) {
55            t.Parallel() // Run subtests in parallel
56 
57            result := strings.ToUpper(tt.input)
58            if result != tt.want {
59                t.Errorf("got %q, want %q", result, tt.want)
60            }
61        })
62    }
63}
64```
65 
66## Test Helpers and Setup/Teardown
67 
68```go
69func TestWithSetup(t *testing.T) {
70    // Setup
71    db := setupTestDB(t)
72    defer cleanupTestDB(t, db)
73 
74    tests := []struct {
75        name string
76        user User
77    }{
78        {"valid user", User{Name: "John", Email: "[email protected]"}},
79        {"empty name", User{Name: "", Email: "[email protected]"}},
80    }
81 
82    for _, tt := range tests {
83        t.Run(tt.name, func(t *testing.T) {
84            err := db.SaveUser(tt.user)
85            if err != nil {
86                t.Fatalf("SaveUser failed: %v", err)
87            }
88        })
89    }
90}
91 
92// Helper function (doesn't show in stack trace)
93func setupTestDB(t *testing.T) *DB {
94    t.Helper()
95 
96    db, err := NewDB(":memory:")
97    if err != nil {
98        t.Fatalf("failed to create test DB: %v", err)
99    }
100    return db
101}
102 
103func cleanupTestDB(t *testing.T, db *DB) {
104    t.Helper()
105 
106    if err := db.Close(); err != nil {
107        t.Errorf("failed to close DB: %v", err)
108    }
109}
110```
111 
112## Mocking with Interfaces
113 
114```go
115// Interface to mock
116type EmailSender interface {
117    Send(to, subject, body string) error
118}
119 
120// Mock implementation
121type MockEmailSender struct {
122    SentEmails []Email
123    ShouldFail bool
124}
125 
126type Email struct {
127    To, Subject, Body string
128}
129 
130func (m *MockEmailSender) Send(to, subject, body string) error {
131    if m.ShouldFail {
132        return fmt.Errorf("failed to send email")
133    }
134    m.SentEmails = append(m.SentEmails, Email{to, subject, body})
135    return nil
136}
137 
138// Test using mock
139func TestUserService_Register(t *testing.T) {
140    mockSender := &MockEmailSender{}
141    service := NewUserService(mockSender)
142 
143    err := service.Register("[email protected]")
144    if err != nil {
145        t.Fatalf("Register failed: %v", err)
146    }
147 
148    if len(mockSender.SentEmails) != 1 {
149        t.Errorf("expected 1 email sent, got %d", len(mockSender.SentEmails))
150    }
151 
152    email := mockSender.SentEmails[0]
153    if email.To != "[email protected]" {
154        t.Errorf("expected email to [email protected], got %s", email.To)
155    }
156}
157```
158 
159## Benchmarking
160 
161```go
162func BenchmarkAdd(b *testing.B) {
163    for i := 0; i < b.N; i++ {
164        Add(100, 200)
165    }
166}
167 
168// Benchmark with subtests
169func BenchmarkStringOperations(b *testing.B) {
170    benchmarks := []struct {
171        name  string
172        input string
173    }{
174        {"short", "hello"},
175        {"medium", strings.Repeat("hello", 10)},
176        {"long", strings.Repeat("hello", 100)},
177    }
178 
179    for _, bm := range benchmarks {
180        b.Run(bm.name, func(b *testing.B) {
181            for i := 0; i < b.N; i++ {
182                _ = strings.ToUpper(bm.input)
183            }
184        })
185    }
186}
187 
188// Benchmark with setup
189func BenchmarkMapOperations(b *testing.B) {
190    m := make(map[string]int)
191    for i := 0; i < 1000; i++ {
192        m[fmt.Sprintf("key%d", i)] = i
193    }
194 
195    b.ResetTimer() // Don't count setup time
196 
197    for i := 0; i < b.N; i++ {
198        _ = m["key500"]
199    }
200}
201 
202// Parallel benchmark
203func BenchmarkConcurrentAccess(b *testing.B) {
204    var counter int64
205 
206    b.RunParallel(func(pb *testing.PB) {
207        for pb.Next() {
208            atomic.AddInt64(&counter, 1)
209        }
210    })
211}
212 
213// Memory allocation benchmark
214func BenchmarkAllocation(b *testing.B) {
215    b.ReportAllocs() // Report allocations
216 
217    for i := 0; i < b.N; i++ {
218        s := make([]int, 1000)
219        _ = s
220    }
221}
222```
223 
224## Fuzzing (Go 1.18+)
225 
226```go
227func FuzzReverse(f *testing.F) {
228    // Seed corpus
229    testcases := []string{"hello", "world", "123", ""}
230    for _, tc := range testcases {
231        f.Add(tc)
232    }
233 
234    f.Fuzz(func(t *testing.T, input string) {
235        reversed := Reverse(input)
236        doubleReversed := Reverse(reversed)
237 
238        if input != doubleReversed {
239            t.Errorf("Reverse(Reverse(%q)) = %q, want %q", input, doubleReversed, input)
240        }
241    })
242}
243 
244// Fuzz with multiple parameters
245func FuzzAdd(f *testing.F) {
246    f.Add(1, 2)
247    f.Add(0, 0)
248    f.Add(-1, 1)
249 
250    f.Fuzz(func(t *testing.T, a, b int) {
251        result := Add(a, b)
252 
253        // Properties that should always hold
254        if result < a && b >= 0 {
255            t.Errorf("Add(%d, %d) = %d; result should be >= a when b >= 0", a, b, result)
256        }
257    })
258}
259```
260 
261## Test Coverage
262 
263```go
264// Run tests with coverage:
265// go test -cover
266// go test -coverprofile=coverage.out
267// go tool cover -html=coverage.out
268 
269func TestCalculate(t *testing.T) {
270    tests := []struct {
271        name     string
272        input    int
273        expected int
274    }{
275        {"zero", 0, 0},
276        {"positive", 5, 25},
277        {"negative", -3, 9},
278    }
279 
280    for _, tt := range tests {
281        t.Run(tt.name, func(t *testing.T) {
282            result := Calculate(tt.input)
283            if result != tt.expected {
284                t.Errorf("Calculate(%d) = %d; want %d", tt.input, result, tt.expected)
285            }
286        })
287    }
288}
289```
290 
291## Race Detector
292 
293```go
294// Run with: go test -race
295 
296func TestConcurrentAccess(t *testing.T) {
297    var counter int
298    var wg sync.WaitGroup
299 
300    // This will fail with -race if not synchronized
301    for i := 0; i < 10; i++ {
302        wg.Add(1)
303        go func() {
304            defer wg.Done()
305            counter++ // Data race!
306        }()
307    }
308 
309    wg.Wait()
310}
311 
312// Fixed version with mutex
313func TestConcurrentAccessSafe(t *testing.T) {
314    var counter int
315    var mu sync.Mutex
316    var wg sync.WaitGroup
317 
318    for i := 0; i < 10; i++ {
319        wg.Add(1)
320        go func() {
321            defer wg.Done()
322            mu.Lock()
323            counter++
324            mu.Unlock()
325        }()
326    }
327 
328    wg.Wait()
329 
330    if counter != 10 {
331        t.Errorf("expected 10, got %d", counter)
332    }
333}
334```
335 
336## Golden Files
337 
338```go
339import (
340    "os"
341    "path/filepath"
342    "testing"
343)
344 
345func TestRenderHTML(t *testing.T) {
346    data := Data{Title: "Test", Content: "Hello"}
347    result := RenderHTML(data)
348 
349    goldenFile := filepath.Join("testdata", "expected.html")
350 
351    if *update {
352        // Update golden file: go test -update
353        os.WriteFile(goldenFile, []byte(result), 0644)
354    }
355 
356    expected, err := os.ReadFile(goldenFile)
357    if err != nil {
358        t.Fatalf("failed to read golden file: %v", err)
359    }
360 
361    if result != string(expected) {
362        t.Errorf("output doesn't match golden file\ngot:\n%s\nwant:\n%s", result, expected)
363    }
364}
365 
366var update = flag.Bool("update", false, "update golden files")
367```
368 
369## Integration Tests
370 
371```go
372// integration_test.go
373// +build integration
374 
375package myapp
376 
377import (
378    "testing"
379    "time"
380)
381 
382func TestIntegration(t *testing.T) {
383    if testing.Short() {
384        t.Skip("skipping integration test in short mode")
385    }
386 
387    // Long-running integration test
388    server := startTestServer(t)
389    defer server.Stop()
390 
391    time.Sleep(100 * time.Millisecond) // Wait for server
392 
393    client := NewClient(server.URL)
394    resp, err := client.Get("/health")
395    if err != nil {
396        t.Fatalf("health check failed: %v", err)
397    }
398 
399    if resp.Status != "ok" {
400        t.Errorf("expected status ok, got %s", resp.Status)
401    }
402}
403 
404// Run: go test -tags=integration
405// Run short tests only: go test -short
406```
407 
408## Testable Examples
409 
410```go
411// Example tests that appear in godoc
412func ExampleAdd() {
413    result := Add(2, 3)
414    fmt.Println(result)
415    // Output: 5
416}
417 
418func ExampleAdd_negative() {
419    result := Add(-2, -3)
420    fmt.Println(result)
421    // Output: -5
422}
423 
424// Unordered output
425func ExampleKeys() {
426    m := map[string]int{"a": 1, "b": 2, "c": 3}
427    keys := Keys(m)
428    for _, k := range keys {
429        fmt.Println(k)
430    }
431    // Unordered output:
432    // a
433    // b
434    // c
435}
436```
437 
438## Quick Reference
439 
440| Command | Description |
441|---------|-------------|
442| `go test` | Run tests |
443| `go test -v` | Verbose output |
444| `go test -run TestName` | Run specific test |
445| `go test -bench .` | Run benchmarks |
446| `go test -cover` | Show coverage |
447| `go test -race` | Run race detector |
448| `go test -short` | Skip long tests |
449| `go test -fuzz FuzzName` | Run fuzzing |
450| `go test -cpuprofile cpu.prof` | CPU profiling |
451| `go test -memprofile mem.prof` | Memory profiling |
452