Testing in Go

func TestAdd(t *testing.T) {
    cases := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -2, -3, -5},
        {"zero", 0, 5, 5},
        {"mixed sign", -2, 5, 3},
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            result := Add(tc.a, tc.b)
            if result != tc.expected {
                t.Errorf("Add(%d, %d) = %d; want %d", tc.a, tc.b, result, tc.expected)
            }
        })
    }
}

// The alternative: repetitive, and easy to forget updating consistently
func TestAddPositive(t *testing.T) { ... }
func TestAddNegative(t *testing.T) { ... }
func TestAddZero(t *testing.T) { ... }

cases := []struct {
    name    string
    input   string
    want    int
    wantErr bool
}{
    {"valid number", "42", 42, false},
    {"invalid input", "abc", 0, true},
}

for _, tc := range cases {
    t.Run(tc.name, func(t *testing.T) {
        got, err := ParseNumber(tc.input)
        if (err != nil) != tc.wantErr {
            t.Fatalf("unexpected error state: %v", err)
        }
        if got != tc.want {
            t.Errorf("got %d, want %d", got, tc.want)
        }
    })
}

func TestValidate(t *testing.T) {
    cases := map[string]struct {
        input string
        valid bool
    }{
        "empty":     {"", false},
        "valid":     {"ok@example.com", true},
        "no-at":     {"nope", false},
    }
    for name, tc := range cases {
        t.Run(name, func(t *testing.T) {
            got := Validate(tc.input)
            if got != tc.valid {
                t.Errorf("Validate(%q) = %v, want %v", tc.input, got, tc.valid)
            }
        })
    }
}

go test -v -run TestValidate

=== RUN   TestValidate/empty
--- PASS: TestValidate/empty
=== RUN   TestValidate/no-at
--- FAIL: TestValidate/no-at
=== RUN   TestValidate/valid
--- PASS: TestValidate/valid

go test -run TestValidate/no-at

for name, tc := range cases {
    tc := tc  // capture for the closure (needed pre-Go 1.22)
    t.Run(name, func(t *testing.T) {
        t.Parallel()   // this subtest runs concurrently with other parallel subtests
        // ...
    })
}

func BenchmarkFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fibonacci(20)
    }
}

go test -bench=Fibonacci -benchmem

BenchmarkFibonacci-8    5000000    287 ns/op    0 B/op    0 allocs/op

func BenchmarkProcessLargeFile(b *testing.B) {
    data := loadLargeTestFixture()  // expensive setup, shouldn't count toward the benchmark
    b.ResetTimer()                  // timer restarts here

    for i := 0; i < b.N; i++ {
        Process(data)
    }
}

func BenchmarkConcat(b *testing.B) {
    b.Run("plus-operator", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            _ = "a" + "b" + "c"
        }
    })
    b.Run("strings-builder", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            var sb strings.Builder
            sb.WriteString("a")
            sb.WriteString("b")
            sb.WriteString("c")
            _ = sb.String()
        }
    })
}

go test -bench=BenchmarkConcat

go test          # runs only Test* functions
go test -bench=. # also runs Benchmark* functions matching "."（every benchmark)

go test -cover ./...

ok      myapp/pkg/validate    0.003s    coverage: 87.5% of statements

go test -coverprofile=cover.out ./...
go tool cover -html=cover.out

func Divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("divide by zero")  // often the red, uncovered line
    }
    return a / b, nil
}

func TestSomething(t *testing.T) {
    result := DoSomethingComplicated()
    _ = result  // "covers" the function, but asserts NOTHING about correctness
}

// Production code depends on a narrow interface, not a concrete *sql.DB
type UserFinder interface {
    FindUser(id int) (*User, error)
}

func GreetUser(f UserFinder, id int) (string, error) {
    u, err := f.FindUser(id)
    if err != nil {
        return "", err
    }
    return "Hello, " + u.Name, nil
}

// Test code: a fake implementation with canned behavior
type fakeUserFinder struct {
    user *User
    err  error
}
func (f *fakeUserFinder) FindUser(id int) (*User, error) {
    return f.user, f.err
}

func TestGreetUser(t *testing.T) {
    fake := &fakeUserFinder{user: &User{Name: "Alice"}}
    got, err := GreetUser(fake, 1)
    if err != nil || got != "Hello, Alice" {
        t.Errorf("got %q, %v", got, err)
    }
}

//go:generate mockgen -source=finder.go -destination=mocks/finder_mock.go

func TestGreetUser_WithGeneratedMock(t *testing.T) {
    ctrl := gomock.NewController(t)
    mockFinder := mocks.NewMockUserFinder(ctrl)
    mockFinder.EXPECT().FindUser(1).Return(&User{Name: "Alice"}, nil)

    got, _ := GreetUser(mockFinder, 1)
    if got != "Hello, Alice" {
        t.Errorf("got %q", got)
    }
}