ਤੁਸੀਂ Go ਕੋਡ ਦੀ ਟੈਸਟਿੰਗ ਕਿਵੇਂ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

Go ਕੋਲ `testing` ਪੈਕੇਜ ਅਤੇ `go test` ਕਮਾਂਡ ਦੁਆਰਾ **ਬਿਲਟ-ਇਨ ਟੈਸਟਿੰਗ** ਹੈ — ਕੋਈ ਬਾਹਰੀ ਫਰੇਮਵਰਕ ਲੋੜੀਂਦਾ ਨਹੀਂ। ਟੈਸਟ `_test.go` ਫਾਇਲਾਂ ਵਿੱਚ ਰਹਿੰਦੇ ਹਨ, ਅਤੇ Go **ਟੇਬਲ-ਚਾਲਿਤ ਟੈਸਟਾਂ**, ਬੈਂਚਮਾਰਕਾਂ, ਅਤੇ ਚੰਗੀ ਟੂਲਿੰਗ ਨੂੰ ਪਹਿਲੇ-ਦਰਜੇ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਜੋਂ ਜ਼ੋਰ ਦਿੰਦਾ ਹੈ।

## ਇੱਕ ਬੁਨਿਆਦੀ ਟੈਸਟ

```go
// math.go
func Add(a, b int) int { return a + b }

// math_test.go — same package, _test.go suffix
import "testing"

func TestAdd(t *testing.T) {     // Test prefix + *testing.T parameter
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2,3) = %d; want 5", result)   // report failure (continues)
        // t.Fatalf stops the test immediately
    }
}
// run with: go test  (or `go test -v` for verbose, `go test ./...` for all packages)
```

ਇੱਕ ਟੈਸਟ ਫੰਕਸ਼ਨ `Test` ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, `*testing.T` ਲੈਂਦਾ ਹੈ, ਅਤੇ `t.Errorf`/`t.Fatalf` ਦੁਆਰਾ ਅਸਫਲਤਾਵਾਂ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ। ਕੋਈ ਦਾਅਵੇ ਦੀ ਕੀਵਰਡਾਂ ਨਹੀਂ ਹਨ — ਤੁਸੀਂ ਸਧਾਰਨ `if` ਦੇ ਨਾਲ ਸ਼ਰਤਾਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹੋ ਅਤੇ ਅਸਫਲਤਾਵਾਂ ਦੀ ਰਿਪੋਰਟ ਕਰਦੇ ਹੋ (Go ਇਸ ਸਪਸ਼ਟ ਸ਼ੈਲੀ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ)।

## ਟੇਬਲ-ਚਾਲਿਤ ਟੈਸਟ — ਮੋਹਰੀ Go ਪੈਟਰਨ

```go
func TestAdd(t *testing.T) {
    tests := []struct {           // a table of test CASES
        name     string
        a, b     int
        expected int
    }{
        {"positives", 2, 3, 5},
        {"with zero", 0, 5, 5},
        {"negatives", -1, -1, -2},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {     // a SUBTEST per case (named, isolated)
            if got := Add(tt.a, tt.b); got != tt.expected {
                t.Errorf("Add(%d,%d) = %d; want %d", tt.a, tt.b, got, tt.expected)
            }
        })
    }
}
```

**ਟੇਬਲ-ਚਾਲਿਤ ਟੈਸਟ** ਪ্ರভাবশালী Go ਲਾਂਛਨ ਹਨ — ਕੇਸਾਂ ਦੀ ਇੱਕ ਸਲਾਈਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, `t.Run` ਸਬ-ਟੈਸਟਾਂ ਦੇ ਨਾਲ ਉਹਨਾਂ ਉੱਪਰ ਲੂਪ ਕਰੋ। ਇਹ ਕੇਸਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਮਾਮੂਲੀ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਪ੍ਰਤੀ ਕੇਸ ਸਪੱਸ਼ਟ, ਵਿਅਕਤੀਗਤ ਪਾਸ/ਫੇਲ ਰਿਪੋਰਟਿੰਗ ਦਿੰਦਾ ਹੈ।

## ਬੈਂਚਮਾਰਕ — ਬਿਲਟ-ਇਨ ਪ੍ਰਦਰਸ਼ਨ ਟੈਸਟਿੰਗ

```go
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {     // the framework chooses b.N for statistical accuracy
        Add(2, 3)
    }
}
// go test -bench=. → reports ns/op (and -benchmem for allocations)
```

## ਕਵਰੇਜ ਅਤੇ ਹੋਰ ਟੂਲਿੰਗ

```bash
go test -cover                    # coverage percentage
go test -coverprofile=c.out       # then: go tool cover -html=c.out (visual report)
go test -race                     # the RACE DETECTOR — finds data races (crucial for concurrency)
go test -run TestAdd              # run specific tests
```

**`-race` ਫਲੈਗ** ਖਾਸ ਤੌਰ ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ — ਇਹ ਸਮਵਰਤੀ ਕੋਡ ਵਿੱਚ ਡੇਟਾ ਰੇਸ ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ, Go ਦੀ ਸਮਵਰਤੀਤਾ ਫੋਕਸ ਦਿੱਤੇ ਇੱਕ ਮੁੱਖ ਸੰਦ।

## ਟੈਸਟ ਹੈਲਪਰ ਅਤੇ ਸੈਟਅੱਪ

```go
func TestMain(m *testing.M) {     // package-level setup/teardown
    setup()
    code := m.Run()
    teardown()
    os.Exit(code)
}
// t.Helper() marks a function as a test helper (better failure line reporting)
// httptest package for testing HTTP handlers; interfaces for mocking dependencies
```

## ਇਹ ਕਿਉਂ ਮਾਹਿਰ ਹੈ

ਟੈਸਟਿੰਗ Go ਦਾ ਇੱਕ ਪਹਿਲੇ-ਦਰਜੇ ਦਾ, ਬਿਲਟ-ਇਨ ਹਿੱਸਾ ਹੈ — `testing` ਪੈਕੇਜ ਅਤੇ `go test` ਨੂੰ ਕੋਈ ਬਾਹਰੀ ਫਰੇਮਵਰਕ ਦੀ ਲੋੜ ਨਹੀਂ, ਜੋ ਟੈਸਟਿੰਗ ਨੂੰ ਇੱਕ ਮੂਲ ਅਭਿਆਸ ਦੇ ਰੂਪ ਵਿੱਚ Go ਦੇ ਜੋਰ ਨੂੰ ਪ੍ਰਤੀਬਿੰਬਤ ਕਰਦਾ ਹੈ।

ਪਰਿਪਾਟੀਆਂ ਨੂੰ ਸਮਝਣਾ ਜਰੂਰੀ ਰੋਜ਼ਮਰ੍ਹਾ ਦਾ ਗਿਆਨ ਹੈ: `_test.go` ਫਾਇਲ ਅਤੇ `TestXxx(t *testing.T)` ਢਾਂਚਾ, ਸਪਸ਼ਟ (ਦਾਅਵੇ-ਰਹਿਤ) ਅਸਫਲਤਾ-ਰਿਪੋਰਟਿੰਗ ਸ਼ੈਲੀ, ਅਤੇ ਖਾਸ ਤੌਰ ਤੇ **ਟੇਬਲ-ਚਾਲਿਤ ਟੈਸਟ** ਪੈਟਰਨ ਜੋ ਰਿਹਾਇਸ਼ਲਾ Go ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ (ਸਬ-ਟੈਸਟਾਂ ਦੁਆਰਾ ਸਪੱਸ਼ਟ ਪ੍ਰਤੀ-ਕੇਸ ਰਿਪੋਰਟਿੰਗ ਨਾਲ ਗੇੜੀ ਨਾਲ ਬਹੁਤ ਸਾਰੇ ਕੇਸਾਂ ਨੂੰ ਕਵਰ ਕਰਨਾ)।

ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਨ Go ਦੇ ਬਿਲਟ-ਇਨ **ਬੈਂਚਮਾਰਕ** ਹਨ (ਪ੍ਰਦਰਸ਼ਨ ਇੱਕ ਪਰਖ ਕਰਨ ਯੋਗ ਸਮੱਸਿਆ ਵਜੋਂ) ਅਤੇ ਸ਼ਕਤੀਸ਼ਾਲੀ **ਟੂਲਿੰਗ** — ਕਵਰੇਜ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਖਾਸ ਤੌਰ ਤੇ **`-race` ਖੋਜੀ**, ਜੋ ਸਮਵਰਤੀ ਕੋਡ ਵਿੱਚ ਡੇਟਾ ਰੇਸ ਲੱਭਦਾ ਹੈ (Go ਦੀ ਸਮਵਰਤੀਤਾ-ਭਾਰੀ ਵਰਤੋਂ ਦਿੱਤੇ ਜ਼ਰੂਰੀ)।

ਪ੍ਰਭਾਵਸ਼ਾਲੀ, ਮੋਹਰੀ Go ਟੈਸਟ ਲਿਖਣ, ਰੇਸ ਖੋਜੀ ਦੀ ਵਰਤੋਂ, ਅਤੇ ਵਾਸਤਵਿਕ ਭਾਗਾਂ ਦੀ ਟੈਸਟਿੰਗ ਲਈ `httptest`/ਇੰਟਰਫੇਸ ਦਾ ਲਾਭ ਉਠਾਉਣਾ ਜਾਣਨਾ ਪ੍ਰੋਫੈਸ਼ਨਲ Go ਵਿਕਾਸ ਦੀ ਇੱਕ ਅਲੰਕਾਰਿਕ ਅਤੇ ਕੋਡ-ਗੁਣਵੱਤਾ ਦੁਸ਼ਾਖੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਅਕਸਰ ਵਿਸ਼ਾ ਹੈ।