`சோதனை` தொகுப்பு

Go இல், சோதனைகள் stdlib இன் பகுதியாகும்: வெளிப்புற நூலகம் இல்லை, கட்டமைக்க கட்டமைப்பு இல்லை. உங்களுக்கு தேவையானது *_test.go குறியீட்டிற்கு அடுத்துள்ள கோப்பு, சில TestXxx செயல்பாடுகள் மற்றும் go test கட்டளை.

அடிப்படை மரபுகள்

• சோதனைக் கோப்புகள் <something>_test.go எனப் பெயரிடப்பட்டு, அவை சோதிக்கும் குறியீடாக அதே தொகுப்பில் இருக்கும் (அல்லது "பிளாக்-பாக்ஸ் சோதனைகளுக்கான" <name>_test தொகுப்பில்).
• சோதனைச் செயல்பாடுகளில் சரியான கையொப்பம் உள்ளது: func TestXxx(t *testing.T) இங்கு Xxx என்பது பெரிய எழுத்துடன் தொடங்குகிறது.
• நீங்கள் stdlib இலிருந்து testing இறக்குமதி செய்கிறீர்கள்.
• இல்லை assertEquals: fmt-வினைச்சொற்களுடன் if got != want { t.Errorf(...) } ஐப் பயன்படுத்துகிறீர்கள்.

// 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)
}