t.Error și t.Fatal în Go

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.

Scrie un fișier de test Go în care Add are un bug (returnează doar pe a, ignorându-l pe b), iar TestAdd verifică trei sume diferite cu t.Errorf, astfel încât fiecare caz stricat să fie raportat. Arată rezultatul comenzii go test -v, cu toate cele trei mesaje de eșec într-o singură rulare.

> Ieșire: program Go și rezultatul capturat

Prompt

Scrie un fișier de test Go în care Add are un bug (returnează doar pe a, ignorându-l pe b), iar TestAdd verifică trei sume diferite cu t.Errorf, astfel încât fiecare caz stricat să fie raportat. Arată rezultatul comenzii go test -v, cu toate cele trei mesaje de eșec într-o singură rulare.

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ă.

Scrie un fișier de test Go în care o funcție Split ar trebui să împartă un șir separat prin virgule, dar are un bug (împarte după caracterul greșit). Testul verifică mai întâi numărul de părți cu t.Fatalf, apoi verifică prima parte cu t.Errorf. Arată rezultatul comenzii go test -v, în care fatalul oprește testul înainte de a doua verificare.

> Ieșire: program Go și rezultatul capturat

Prompt

Scrie un fișier de test Go în care o funcție Split ar trebui să împartă un șir separat prin virgule, dar are un bug (împarte după caracterul greșit). Testul verifică mai întâi numărul de părți cu t.Fatalf, apoi verifică prima parte cu t.Errorf. Arată rezultatul comenzii go test -v, în care fatalul oprește testul înainte de a doua verificare.

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.

Scrie un fișier de test Go cu o funcție IsEven și un test care verifică faptul că IsEven(4) este true și IsEven(3) este false, folosind mesaje simple t.Error, fără verbe de formatare. Arată rezultatul trecut al comenzii go test -v.

> Ieșire: program Go și rezultatul capturat

Prompt

Scrie un fișier de test Go cu o funcție IsEven și un test care verifică faptul că IsEven(4) este true și IsEven(3) este false, folosind mesaje simple t.Error, fără verbe de formatare. Arată rezultatul trecut al comenzii go test -v.

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