Două moduri de a eșua
Un test poate raporta o problemă în două moduri, iar diferența este ce se întâmplă după:
t.Errorf marchează testul ca eșuat și merge mai departe. Restul testului rulează în continuare, așa că o singură rulare poate raporta mai multe probleme deodată.
t.Fatalf marchează testul ca eșuat și îl oprește imediat. Folosește-l atunci când continuarea nu mai are sens — liniile următoare ar crăpa sau ar produce zgomot.
Amândouă au un geamăn simplu, fără formatare: t.Error(...) și t.Fatal(...) doar afișează argumentele primite.
t.Errorf: raportează și continuă
Când un test verifică mai multe cazuri unul după altul, t.Errorf este unealta potrivită: un caz stricat este raportat, iar cazurile următoare sunt verificate în continuare.
Astfel, o singură rulare go test îți arată toată paguba — nu doar primul caz stricat.
Vezi toate cazurile stricate deodată
Acest Add îl ignoră pe b, așa că toate cele trei verificări eșuează. Pentru că folosesc t.Errorf, toate cele trei mesaje apar într-o singură rulare — cu t.Fatalf l-ai vedea doar pe primul.
Ieșire: program Go și rezultatul capturat
package calc
import "testing"
// Add are un bug: îl ignoră pe b.
func Add(a, b int) int {
return a
}
func TestAdd(t *testing.T) {
if got := Add(2, 2); got != 4 {
t.Errorf("Add(2, 2) = %d; așteptat 4", got)
}
if got := Add(2, 3); got != 5 {
t.Errorf("Add(2, 3) = %d; așteptat 5", got)
}
if got := Add(10, 1); got != 11 {
t.Errorf("Add(10, 1) = %d; așteptat 11", got)
}
}
t.Fatalf: oprește imediat
Uneori o verificare eșuată înseamnă că restul testului nu mai poate funcționa. Un caz tipic: testul pregătește mai întâi o valoare, apoi o inspectează. Dacă pregătirea a mers deja prost, inspectarea ar fi inutilă sau ar duce chiar la o crăpare.
t.Fatalf oprește testul chiar acolo. Verificările de după el nu mai rulează niciodată — și exact asta se dorește.
Oprește-te înaintea verificărilor inutile
Split are un bug (împarte după caracterul greșit), așa că se întoarce 1 parte în loc de 3. t.Fatalf raportează asta și oprește testul — verificarea primei părți de mai jos nu mai este atinsă niciodată.
Ieșire: program Go și rezultatul capturat
package words
import (
"strings"
"testing"
)
// Split are un bug: împarte după ";" în loc de ",".
func Split(s string) []string {
return strings.Split(s, ";")
}
func TestSplit(t *testing.T) {
parts := Split("one,two,three")
if len(parts) != 3 {
t.Fatalf("obținut %d părți, așteptat 3 — nu le pot verifica", len(parts))
}
// Nu este atins niciodată cât timp bugul este acolo.
if parts[0] != "one" {
t.Errorf("prima parte = %q; așteptat %q", parts[0], "one")
}
}
Error și Fatal fără formatare
Când nu ai nevoie de substituenții %d sau %q, folosește formele simple: t.Error("mesaj") și t.Fatal("mesaj"). Se comportă exact ca gemenii lor cu f — raportează și continuă sau raportează și opresc.
Mesaje simple
Două verificări booleene simple, cu mesaje t.Error fără formatare. Amândouă trec aici, așa că mesajele rămân tăcute, iar rularea afișează PASS.
Ieșire: program Go și rezultatul capturat
package calc
import "testing"
func IsEven(n int) bool {
return n%2 == 0
}
func TestIsEven(t *testing.T) {
if !IsEven(4) {
t.Error("4 ar trebui să fie par")
}
if IsEven(3) {
t.Error("3 nu ar trebui să fie par")
}
}