Go માં built-in testing છે testing package અને go test command દ્વારા — કોઈ બાહ્ય framework ની જરૂર નથી. Tests _test.go ફાઇલોમાં રહે છે, અને Go table-driven tests, benchmarks, અને સારા tooling ને first-class features તરીકે મજબૂત રીતે જોર આપે છે.
// 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 function Test થી શરૂ થાય છે, *testing.T લે છે, અને t.Errorf/t.Fatalf દ્વારા failures રિપોર્ટ કરે છે. કોઈ assertion keywords નથી — તમે conditions ને સાધારણ if સાથે ચેક કરો અને failures રિપોર્ટ કરો (Go આ explicit style ને પસંદ કરે છે).
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)
}
})
}
}
Table-driven tests આ પ્રમુખ Go idiom છે — cases ની slice define કરો, t.Run subtests સાથે તેમ પર loop કરો. આ cases ને ઉમેરવાનું trivial બનાવે છે અને દરેક case માટે સ્પષ્ટ, અલગ pass/fail રિપોર્ટિંગ આપે છે.
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)
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 flag ખાસ મહત્વપૂર્ણ છે — તે concurrent code માં data races શોધે છે, Go ની concurrency focus આપેલ એક મુખ્ય tool.
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
Testing Go માં first-class, built-in ભાગ છે — testing package અને go test કોઈ બાહ્ય framework ને જરૂર કરતા નથી, જે Go ની testing ને મૂળ practice તરીકે લેવાની જોર પ્રતિબિંબિત કરે છે.
Conventions ને સમજવું આવશ્યક રોજિંદ્દનું જ્ઞાન છે: _test.go ફાઇલ અને TestXxx(t *testing.T) structure, explicit (assertion-less) failure-reporting style, અને ખાસ કરીને table-driven test pattern જે idiomatic Go પર પ્રભુત્વ ધરાવે છે (સ્પષ્ટ per-case રિપોર્ટિંગ સાથે subtests દ્વારા ઘણા cases ને કોમ્પેક્ટલી આવરી લે છે).
સમાન મહત્વપૂર્ણ Go ના built-in benchmarks (performance ને testable concern તરીકે) અને શક્તિશાળી tooling છે — coverage analysis અને ખાસ કરીને -race detector, જે concurrent code માં data races શોધે છે (Go ની concurrency-heavy use આપેલ vital).
જાણવું કે કેવી રીતે અસરકારક, idiomatic Go tests લખવા, race detector વાપરવો, અને testing real components માટે httptest/interfaces ને leverage કરવું તે professional Go development ની નિશાની છે અને code-quality fluency પ્રતિબિંબિત કરતી વારંવાર topic છે.
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો