Testing in Go 🐹

// math.go — the code you want to test.
package mathutil

func Add(a, b int) int {
    return a + b
}

// math_test.go — tests MUST live in a file ending in _test.go,
// in the same package. The compiler treats _test.go files specially:
// they are only built when you run "go test", never in your app.
package mathutil

import "testing"

// Rules for a test function:
//   - name starts with Test followed by a Capital letter (TestAdd)
//   - it takes exactly one argument: t *testing.T
func TestAdd(t *testing.T) {
    got := Add(2, 3)     // call the thing under test
    want := 5            // what you expect

    // There is no assert keyword in Go. You compare yourself and,
    // on failure, report it via t. t.Errorf marks the test failed
    // but keeps running the rest of the function.
    if got != want {
        t.Errorf("Add(2, 3) = %d; want %d", got, want)
    }
}

$ go test
ok      myproject/mathutil  0.003s

$ go test -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
PASS
ok      myproject/mathutil  0.003s

package mathutil

import "testing"

func Divide(a, b int) int { return a / b }

func TestDivide(t *testing.T) {
    // t.Fatalf reports the failure AND stops this test immediately
    // (via runtime.Goexit). Use it when continuing makes no sense —
    // here, if b is 0 the next line would panic, so we bail out first.
    b := 2
    if b == 0 {
        t.Fatalf("b is 0; cannot divide")   // stops the test now
    }

    got := Divide(10, b)
    // t.Errorf reports the failure but KEEPS GOING, so one run can
    // surface several problems at once.
    if got != 5 {
        t.Errorf("Divide(10, 2) = %d; want 5", got)
    }
}

$ go test -v
=== RUN   TestDivide
--- PASS: TestDivide (0.00s)
PASS
ok      myproject/mathutil  0.002s

package mathutil

import "testing"

func Double(n int) int { return n * 2 }

// 🎯 YOUR TURN — finish this test, then run "go test -v".
func TestDouble(t *testing.T) {
    got := Double(4)
    want := ___          // 👉 the number you expect Double(4) to return

    // 👉 compare got and want; on mismatch call t.Errorf with a message
    if got ___ want {    // 👉 use the "not equal" operator here
        t.Errorf("Double(4) = %d; want %d", got, want)
    }
}

// ✅ Expected output when correct:
// === RUN   TestDouble
// --- PASS: TestDouble (0.00s)
// PASS

package mathutil

import "testing"

// Table-driven tests are Go's signature pattern: describe each case
// as DATA in a slice, then loop and run each one as a named subtest.
func TestAdd(t *testing.T) {
    // An anonymous struct describes the shape of one test case.
    tests := []struct {
        name string   // a label for this case (shows up in -v output)
        a, b int      // inputs
        want int      // expected result
    }{
        {"two positives", 2, 3, 5},
        {"two negatives", -1, -2, -3},
        {"with zero", 0, 7, 7},
        {"mixed signs", -5, 10, 5},
    }

    for _, tt := range tests {
        // t.Run starts a SUBTEST named after the case. Each subtest
        // passes or fails on its own, so you see exactly which case broke.
        t.Run(tt.name, func(t *testing.T) {
            if got := Add(tt.a, tt.b); got != tt.want {
                t.Errorf("Add(%d, %d) = %d; want %d",
                    tt.a, tt.b, got, tt.want)
            }
        })
    }
}

$ go test -v
=== RUN   TestAdd
=== RUN   TestAdd/two_positives
=== RUN   TestAdd/two_negatives
=== RUN   TestAdd/with_zero
=== RUN   TestAdd/mixed_signs
--- PASS: TestAdd (0.00s)
    --- PASS: TestAdd/two_positives (0.00s)
    --- PASS: TestAdd/two_negatives (0.00s)
    --- PASS: TestAdd/with_zero (0.00s)
    --- PASS: TestAdd/mixed_signs (0.00s)
PASS
ok      myproject/mathutil  0.004s

package mathutil

import "testing"

func Max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func TestMax(t *testing.T) {
    tests := []struct {
        name string
        a, b int
        want int
    }{
        {"a bigger", 9, 4, 9},
        {"b bigger", 2, 8, 8},
        // 🎯 YOUR TURN — add ONE more case to the table below.
        // 👉 a case where both numbers are equal, e.g. 5 and 5.
        ___,   // 👉 {"name", a, b, want}  — fill in all four fields
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := Max(tt.a, tt.b); got != tt.want {
                t.Errorf("Max(%d, %d) = %d; want %d",
                    tt.a, tt.b, got, tt.want)
            }
        })
    }
}

// ✅ Expected: your new subtest appears and passes, e.g.
//     --- PASS: TestMax/equal (0.00s)

# Run every test in the current package
go test

# -v: verbose — show each test and subtest as it runs
go test -v

# -run: only tests whose name matches a regex.
#   "TestAdd" runs TestAdd; "TestAdd/zero" targets one subtest.
go test -run TestAdd
go test -run 'TestAdd/with_zero' -v

# -cover: what percentage of statements your tests exercise
go test -cover

# ./... means "this package and every package below it"
go test ./...

# Combine them freely:
go test -v -run TestMax -cover ./...

$ go test -cover
PASS
coverage: 92.3% of statements
ok      myproject/mathutil  0.004s

$ go test -run 'TestAdd/with_zero' -v
=== RUN   TestAdd
=== RUN   TestAdd/with_zero
--- PASS: TestAdd (0.00s)
    --- PASS: TestAdd/with_zero (0.00s)
PASS
ok      myproject/mathutil  0.003s

package mathutil

import "testing"

// A BENCHMARK measures speed. Name it Benchmark + Capital, take a
// *testing.B, and loop exactly b.N times. The framework keeps raising
// b.N until the timing is stable, then reports the per-operation cost.
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

// Benchmarks DON'T run with a plain "go test" — you opt in with -bench.
//   go test -bench=.            run all benchmarks
//   go test -bench=. -benchmem  also report memory per operation

$ go test -bench=. -benchmem
goos: linux
goarch: amd64
pkg: myproject/mathutil
BenchmarkAdd-8   1000000000   0.27 ns/op   0 B/op   0 allocs/op
PASS
ok      myproject/mathutil  0.34s