'परीक्षण' पैकेज

गो में, परीक्षण stdlib का हिस्सा हैं: कोई बाहरी लाइब्रेरी नहीं, कॉन्फ़िगर करने के लिए कोई ढांचा नहीं। आपको बस कोड के आगे एक *_test.go फ़ाइल, कुछ TestXxx फ़ंक्शन और go test कमांड की आवश्यकता है।

बुनियादी परंपराएँ

• परीक्षण फ़ाइलों को <something>_test.go नाम दिया गया है और वे जिस कोड का परीक्षण करते हैं उसी पैकेज** में रहते हैं (या "ब्लैक-बॉक्स परीक्षण" के लिए <name>_test पैकेज में)।
• परीक्षण कार्यों में एक सटीक हस्ताक्षर होता है: func TestXxx(t *testing.T) जहां Xxx एक बड़े अक्षर से शुरू होता है।
• आप stdlib से testing आयात करते हैं।
• नहीं assertEquals: आप if got != want { t.Errorf(...) } का उपयोग fmt-क्रियाओं के साथ करते हैं।

// math.go
package math

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

// math_test.go
package math

import "testing"

func TestSum(t *testing.T) {
    got := Sum(2, 3)
    if got != 5 {
        t.Errorf("Sum(2,3) = %d; voglio %d", got, 5)
    }
}

इसे इसके साथ चलाएँ:

go test ./...        # all packages in the module
go test -v ./pkg     # verbose: prints test names
go test -run TestSum  # only tests matching the regex

t.Error बनाम t.Fatal

विफलता का संकेत देने वाली ये दो मूल क्रियाएं हैं:

अंगूठे का नियम: जब जारी रखने का कोई मतलब नहीं हो तो Fatal का उपयोग करें (उदाहरण के लिए विफल सेटअप, आसन्न शून्य सूचक विचलन); अन्यथा Error, जो आपको एक ही बार में सभी विफलताओं को देखने देता है।

func TestOpen(t *testing.T) {
    f, err := os.Open("fixtures/sample.txt")
    if err != nil {
        t.Fatal(err) // if it doesn't open, the next steps would fail on nil
    }
    defer f.Close()
    // ... assert on content with t.Errorf
}

t.Cleanup के साथ सेटअप और टियरडाउन

किसी परीक्षण (या उप-परीक्षण) के अंत में संसाधन जारी करने के लिए, defer के बजाय t.Cleanup का उपयोग करें:

func TestDB(t *testing.T) {
    db := newTestDB(t)
    t.Cleanup(func() { db.Close() })
    // ... test
}

defer पर लाभ: db बनाने वाला सहायक आंतरिक सफाई को पंजीकृत कर सकता है, इसलिए कॉल करने वालों को इसे याद रखने की आवश्यकता नहीं है।

परीक्षण सहायक

t.Helper() विधि एक फ़ंक्शन को "सहायक" के रूप में चिह्नित करती है: जब कोई परीक्षण विफल हो जाता है, तो स्टैक ट्रेस सहायक फ़ंक्शन को छोड़ देता है और सीधे कॉलर को इंगित करता है:

func mustParseInt(t *testing.T, s string) int {
    t.Helper()
    n, err := strconv.Atoi(s)
    if err != nil {
        t.Fatalf("parse %q: %v", s, err)
    }
    return n
}

अभ्यास

if err != nil {
  t.???(err)
}