`టెస్టింగ్` ప్యాకేజీ

Goలో, పరీక్షలు 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 vs 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)
}