அட்டவணை சார்ந்த சோதனைகள்

அட்டவணையால் இயக்கப்படும் சோதனைகள் என்பது Go இன் இடியோமடிக் பேட்டர்ன்: N தனித்தனி TestThisSpecificCase செயல்பாடுகளை எழுதுவதற்குப் பதிலாக, நீங்கள் வழக்குகளின் ஒரு பகுதியை அறிவித்து மீண்டும் செய்கிறீர்கள். ஒரு வலியுறுத்தல் தொகுதி உள்ளது, மேலும் சோதனை தரவு தர்க்கத்திலிருந்து பிரிக்கப்பட்டது.

அடிப்படை முறை

func TestAbs(t *testing.T) {
    cases := []struct {
        name string
        in   int
        want int
    }{
        {"pos", 3, 3},
        {"neg", -3, 3},
        {"zero", 0, 0},
    }
    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            if got := Abs(tc.in); got != tc.want {
                t.Errorf("Abs(%d) = %d; voglio %d", tc.in, got, tc.want)
            }
        })
    }
}

மூன்று பொருட்கள்:

1. அநாமதேய கட்டமைப்பின் ஸ்லைஸ் வழக்கமான புலங்களுடன்: name, உள்ளீடுகள், எதிர்பார்க்கப்படும் வெளியீடு (மற்றும் எதிர்பார்க்கப்படும் பிழையாக இருக்கலாம்).
2. for _, tc := range cases - செயல்படுத்தும் வளையம்.
3. t.Run(tc.name, func(t *testing.T) { ... }) - ஒவ்வொரு வழக்கும் அதன் சொந்த பெயருடன் துணை சோதனையாக மாறும்.

ஏன் t.Run?

t.Run ஒரு துணை சோதனை ஐ உருவாக்குகிறது:

• தனிப்பட்ட பெயர் வெளியீட்டில் காட்டப்பட்டுள்ளது: TestAbs/pos, TestAbs/neg, ...
• அதன் சொந்த t *testing.T: ஒரு வழக்கில் தோல்வி மற்றவற்றை நிறுத்தாது (t.Fatal பயன்படுத்தப்படும் வரை).
• கட்டளை-வரி வடிகட்டுதல்: go test -run TestAbs/neg அந்த வழக்கில் மட்டுமே இயங்கும்.
• விருப்பமான பேரலலிசம்: இணையாக்க, செயல்பாட்டிற்குள் t.Parallel() ஐ அழைக்கவும்.

go test -v -run TestAbs/neg

எதிர்பார்க்கப்படும் பிழைகள் உள்ள வழக்குகள்

cases := []struct {
    name    string
    in      string
    want    int
    wantErr bool
}{
    {"ok", "42", 42, false},
    {"bad", "x", 0, true},
}
for _, tc := range cases {
    t.Run(tc.name, func(t *testing.T) {
        got, err := Atoi(tc.in)
        if (err != nil) != tc.wantErr {
            t.Fatalf("err = %v, wantErr = %v", err, tc.wantErr)
        }
        if !tc.wantErr && got != tc.want {
            t.Errorf("got %d, want %d", got, tc.want)
        }
    })
}

லூப் க்ளோசர் பிட்ஃபால் (ப்ரீ-கோ 1.22)

Go 1.22 க்கு முந்தைய பதிப்புகளில், tc மாறியானது மறு செய்கைகள் முழுவதும் பகிரப்பட்டது: t.Parallel()ஐ t.Run க்குள் அழைப்பது, அனைத்து துணைச் சோதனைகளும் அதே கடைசி கேஸில் இயங்குவதற்கு காரணமாக அமைந்தது. சரி செய்யப்பட்டது:

for _, tc := range cases {
    tc := tc // local rebind (pre-1.22)
    t.Run(tc.name, func(t *testing.T) {
        t.Parallel()
        // ...
    })
}

வழக்குகளை பெயரிடுதல்

சிறந்த நடைமுறைகள்:

• ஒரு குறுகிய ஆனால் தூண்டக்கூடிய பெயர்: "empty input", "too large", "negative".
• நீங்கள் -run உடன் எளிதாக வடிகட்ட விரும்பினால் இடைவெளிகள் இல்லை (அல்லது அடிக்கோடிட்டுகளைப் பயன்படுத்தவும்).
• எப்போதும் "மகிழ்ச்சியான பாதை" வழக்கு, ஒரு "விளிம்பு" வழக்கு (பூஜ்ஜியம், வெற்று) மற்றும் குறைந்தபட்சம் ஒரு பிழை வழக்கு ஆகியவற்றைச் சேர்க்கவும்.

பயிற்சிகள்

for _, tc := range cases {
  t.Run(tc.name, func(t *testing.T) { ... })
}