Skip to content

Modul 9: Testing, Benchmarks & Fuzzing

Go-Software absichern statt hoffen: Table-driven Tests & Subtests, Testhelper wie t.Cleanup, t.Parallel und TestMain, Mocks & Fakes über Interfaces, Benchmarks mit pprof sowie Fuzzing und der Race Detector.

Fortschritt0/5 Lektionen
41

Table-driven Tests & Subtests

Lektion 41 von 100

Ein Test, hundert Fälle

Stell dir vor, wir betreiben einen kleinen Shop, und der Support meldet: „Artikel mit Sonderzeichen erzeugen kaputte URLs.“ Die Ursache ist eine Funktion NormalizeSlug, die Titel in URL-freundliche Slugs umwandelt — und die verhält sich bei Leerzeichen, Umlauten und leeren Strings jeweils anders. Genau solche Funktionen mit vielen Eingabeklassen sind der Klassiker für Bugs.

Die naive Reaktion wäre, für jeden Verdachtsfall eine eigene Testfunktion zu kopieren: TestSlugSimple, TestSlugUmlaut, TestSlugEmpty … Nach dem zehnten Duplikat weiß niemand mehr, welche Fälle schon abgedeckt sind. Go hat für dieses Problem ein idiomatisches Muster, das sich durch die gesamte Standardbibliothek zieht: Table-driven Tests. Die Testfälle stehen als Daten in einer Tabelle — einem Slice anonymer Structs — und eine einzige Testfunktion läuft über alle Zeilen.

Der Fall ist Daten, nicht Code

Bei einem Table-driven Test ist jeder Testfall eine Zeile in einem Slice: name, Eingabe (in) und erwartete Ausgabe (want). Ein neuer Fall kostet eine Zeile, kein neues func Test.... Die Tabelle ist damit gleichzeitig eine Checkliste der Anforderungen — im Code-Review sieht man auf einen Blick, welche Grenzfälle jemand mitgedacht hat.

So sieht das Muster aus — mit Subtests via t.Run, damit jeder Fall einen Namen bekommt:

// slug/slug_test.go
package slug

import (
	"strings"
	"testing"
)

// NormalizeSlug macht aus einem Titel einen URL-freundlichen Slug.
func NormalizeSlug(title string) string {
	s := strings.ToLower(strings.TrimSpace(title))
	s = strings.ReplaceAll(s, " ", "-")
	return strings.Trim(s, "-")
}

func TestNormalizeSlug(t *testing.T) {
	tests := []struct {
		name string
		in   string
		want string
	}{
		{name: "einfacher titel", in: "Go Kurs", want: "go-kurs"},
		{name: "leerzeichen am rand", in: "  Panic  ", want: "panic"},
		{name: "mehrere woerter", in: "goroutines und channels", want: "goroutines-und-channels"},
		{name: "leerer string", in: "", want: ""},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got := NormalizeSlug(tc.in)
			if got != tc.want {
				t.Errorf("NormalizeSlug(%q) = %q, wollte %q", tc.in, got, tc.want)
			}
		})
	}
}

// Terminal: go test ./slug
// → ok  	slug	0.012s

Subtests: jeden Fall einzeln anspringen

Das t.Run in der Schleife ist kein Schmuckwerk. Jede Zeile der Tabelle wird zu einem benannten Subtest, der drei Dinge mitbringt: Failures erscheinen mit dem Fallnamen, man kann mit -run gezielt einen einzelnen Fall nachspielen, und fehlgeschlagene Fälle kann man einzeln im Debugger nachvollziehen, ohne den Rest der Tabelle abzuschalten.

// Terminal: die Umlaut-Regression isoliert nachspielen
//
//	go test -run 'TestNormalizeSlug/mehrere' -v ./slug
//
// → === RUN   TestNormalizeSlug
// → === RUN   TestNormalizeSlug/mehrere_woerter
// → --- PASS: TestNormalizeSlug (0.00s)
// →     --- PASS: TestNormalizeSlug/mehrere_woerter (0.00s)
// → PASS

Die Namen der Subtests ergeben sich aus dem name-Feld — Leerzeichen werden dabei automatisch zu Unterstrichen. Wer seine Fälle klar benennt („leerer string“ statt „case 3“), bekommt Fehlermeldungen, die man ohne Öffnen des Editors versteht.

Für die Assertions gilt eine einfache Regel: t.Errorf meldet den Fehler und lässt den Test weiterlaufen, t.Fatalf bricht sofort ab. Fatalf ist richtig, wenn der folgende Code den geprüften Wert ohnehin nicht mehr sinnvoll verwenden kann — etwa weil er dereferenziert wird. Innerhalb eines Subtests betrifft der Abbruch nur diesen einen Fall.

⚠ Häufiger Fehler: t.Fatalf direkt in der Schleife über die Tabelle aufrufen — ohne t.Run. Fatal beendet dann die gesamte Testfunktion beim ersten fehlschlagenden Fall: Man behebt einen Fall, startet neu, und erst jetzt sieht man den nächsten Fehler. Über t.Run mit t.Errorf sieht man dagegen alle fehlgeschlagenen Fälle in einem einzigen Lauf und nicht der Reihe nach über fünf CI-Durchläufe.

✅ Wichtige Erkenntnisse

Haken setzen, um deinen Lernfortschritt zu markieren:

    42

    Testhelpers: t.Cleanup, t.Parallel & TestMain

    Lektion 42 von 100

    Tests, die hinter sich aufräumen

    Ein Test, der einen HTTP-Server startet, eine Datei schreibt oder eine Datenbankverbindung öffnet, hat eine Pflicht: alles wieder zurückzulassen, wie es war. Sonst verhindert ein leckender File-Handle den nächsten Test, und die Suche nach der Ursache dauert länger als das Schreiben des Tests selbst.

    Go bietet dafür drei Werkzeuge, die zusammen fast jede Test-Infrastruktur abdecken: t.TempDir() für Einweg-Verzeichnisse, t.Cleanup für Teardown-Logik und TestMain für Setup, das das ganze Paket betrifft. Dazu kommt t.Parallel, mit dem Go die wartenden I/O-Tests einer Suite überlappend ausführt — und eine große Suite plötzlich in der Hälfte der Zeit durchläuft.

    Lebensdauer an den Test koppeln, nicht an die Funktion

    t.Cleanup(f) registriert eine Funktion, die erst feuert, wenn der Test fertig ist — in umgekehrter Registrierungsreihenfolge (LIFO), genau wie defer. Der Unterschied zu defer ist der Bezugspunkt: defer in einem Helper läuft, sobald der Helper zurückkehrt. t.Cleanup läuft, sobald der Test fertig ist. Für Ressourcen, die ein Helper an den Test übergibt, ist das der einzige richtige Mechanismus.

    Hier ein Helper, der einen Fake-API-Server startet — samt t.Helper(), damit Fehlermeldungen auf die Zeile im Test zeigen statt auf den Helper:

    // config/config_test.go
    package config
    
    import (
    	"net/http"
    	"net/http/httptest"
    	"os"
    	"path/filepath"
    	"testing"
    )
    
    // newAPIServer startet einen Test-Server, der beim richtigen Token ok sagt.
    func newAPIServer(t *testing.T, token string) *httptest.Server {
    	t.Helper() // Fehler zeigen die Zeile des Tests, nicht des Helpers
    	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    		if r.Header.Get("Authorization") != "Bearer "+token {
    			w.WriteHeader(http.StatusUnauthorized)
    			return
    		}
    		w.Write([]byte(`{"status":"ok"}`))
    	}))
    	t.Cleanup(srv.Close) // feuert erst, wenn der Test fertig ist
    	return srv
    }
    
    func TestFetchStatus(t *testing.T) {
    	t.Parallel() // darf neben anderen parallelen Tests laufen
    
    	srv := newAPIServer(t, "geheim")
    	path := filepath.Join(t.TempDir(), "status.json") // Verzeichnis wird automatisch gelöscht
    
    	if err := fetchToFile(srv.URL, "geheim", path); err != nil {
    		t.Fatalf("fetchToFile: %v", err)
    	}
    	if _, err := os.Stat(path); err != nil {
    		t.Fatalf("Datei fehlt: %v", err)
    	}
    }
    
    // Terminal: go test ./config
    // → ok  	config	0.021s
    
    // Terminal: go test -v ./config
    // → === RUN   TestFetchStatus
    // → --- PASS: TestFetchStatus (0.02s)
    // → PASS
    //
    // Terminal: alle parallelen Tests des Pakets gemeinsam starten
    // → go test -parallel 8 ./...
    

    TestMain: Setup für das ganze Paket

    Manchmal braucht es Zustand, der vor dem ersten Test existieren muss: eine Testdatenbank mit Schema, ein teures Binary oder Umgebungsvariablen. Dafür gibt es TestMain(m *testing.M) — sie ersetzt die main-Funktion des Test-Binaries. Der Ablauf ist immer derselbe: Setup, m.Run() (führt alle Tests aus und liefert deren Exit-Code), Teardown, os.Exit(code).

    // store/main_test.go
    package store
    
    import (
    	"fmt"
    	"os"
    	"testing"
    )
    
    var testDB *DB
    
    func TestMain(m *testing.M) {
    	var err error
    	testDB, err = open("postgres://localhost/shop_test")
    	if err != nil {
    		fmt.Println("Setup fehlgeschlagen:", err)
    		os.Exit(1)
    	}
    
    	code := m.Run() // führt ALLE Tests aus und liefert den Exit-Code
    
    	testDB.Close() // globales Teardown
    	os.Exit(code)  // Exit-Code an die CI weiterreichen
    }
    
    // Terminal: go test ./store
    // → ok  	store	2.418s
    
    // Terminal: go test -v ./store
    // → === RUN   TestOrderInsert
    // → --- PASS: TestOrderInsert (0.03s)
    // → PASS
    //
    // Ohne os.Exit(code) endet das Test-Binary mit Exit-Code 0 —
    // die CI bleibt dann grün, selbst wenn m.Run() FAIL geliefert hat.
    

    ⚠ Häufiger Fehler: defer srv.Close() in einer Helper-Funktion, die den Server an den Test zurückgibt. Das defer feuert beim Verlassen des Helpers — also bevor der Test überhaupt angefangen hat — und der Server ist zu. In Helpern, die Ressourcen übergeben, gehört t.Cleanup hin; defer passt nur innerhalb der Testfunktion selbst, wo der Gültigkeitsbereich deckungsgleich ist.

    ✅ Wichtige Erkenntnisse

    Haken setzen, um deinen Lernfortschritt zu markieren:

      43

      Mocks & Fakes: Interfaces als Test-Seams

      Lektion 43 von 100

      Die Nahtstelle, an der wir austauschen

      Ein Bestellservice soll eine Zahlung an einem Payment-Provider auslösen. Wenn wir dafür in Tests die echte API aufrufen, passiert eines von drei Dingen: Es kostet Geld, es ist langsam, oder es flackert, sobald der Provider Wartung hat. Keine dieser Eigenschaften darf ein Unit-Test haben.

      Die Lösung ist keine Mocking-Bibliothek, sondern ein Sprachmerkmal: Interfaces. Ein Interface definiert die Nahtstelle (Test-Seam) — die Stelle, an der unser Code eine Abhängigkeit nur über ihr Verhalten konsumiert. Im Produktionscode steckt dort die echte Stripe-Anbindung, im Test ein kleiner Fake, der eine Transaktions-ID zurückgibt und sich merkt, womit er aufgerufen wurde.

      Das Interface gehört zum Konsumenten

      In Go definiert der Konsument das Interface, nicht der Produzent. Der Bestellservice deklariert, was er braucht („etwas, das Charge kann“), und die konkrete Zahlungsimplementierung erfüllt diese Anforderung automatisch — Go kennt kein implements. Genau diese implizite Erfüllung macht Interfaces zur perfekten Test-Naht: Der Fake ist ein eigener Typ im Test-Paket, ohne dass die Produktionscode-Seite etwas davon wissen muss.

      Der Produktionscode — das Interface lebt beim Konsumenten, das Feld ist der Austauschpunkt:

      // checkout/checkout.go
      package checkout
      
      import "context"
      
      // PaymentGateway ist alles, was der Service an Zahlungen braucht.
      type PaymentGateway interface {
      	Charge(ctx context.Context, amountCents int) (txID string, err error)
      }
      
      type Order struct {
      	ID          string
      	AmountCents int
      }
      
      type Service struct {
      	gw PaymentGateway // hier wird im Test der Fake eingesteckt
      }
      
      func (s *Service) PlaceOrder(ctx context.Context, o Order) (string, error) {
      	return s.gw.Charge(ctx, o.AmountCents)
      }
      
      // Im Produktionscode steckt hier die echte Anbindung:
      //   svc := &Service{gw: newStripeClient(apiKey)}
      // Aufruf: svc.PlaceOrder(ctx, Order{ID: "A-42", AmountCents: 4999})
      // → txID = "ch_3Ox2...", err = nil
      

      Der Fake im Test — eine Struktur, drei Zeilen Logik:

      // checkout/checkout_test.go
      package checkout
      
      import (
      	"context"
      	"testing"
      )
      
      type fakeGateway struct {
      	charged []int
      }
      
      func (f *fakeGateway) Charge(_ context.Context, amountCents int) (string, error) {
      	f.charged = append(f.charged, amountCents)
      	return "tx_fake_001", nil
      }
      
      func TestPlaceOrderChargesExactlyOnce(t *testing.T) {
      	gw := &fakeGateway{}
      	svc := &Service{gw: gw}
      
      	txID, err := svc.PlaceOrder(context.Background(), Order{ID: "A-42", AmountCents: 4999})
      	if err != nil {
      		t.Fatalf("PlaceOrder: %v", err)
      	}
      	if txID != "tx_fake_001" {
      		t.Errorf("txID = %q, wollte tx_fake_001", txID)
      	}
      	if len(gw.charged) != 1 || gw.charged[0] != 4999 {
      		t.Errorf("Charge wurde aufgerufen mit %v, wollte genau einmal mit 4999", gw.charged)
      	}
      }
      
      // Terminal: go test ./checkout
      // → ok  	checkout	0.009s
      
      // Terminal: go test -v ./checkout
      // → === RUN   TestPlaceOrderChargesExactlyOnce
      // → --- PASS: TestPlaceOrderChargesExactlyOnce (0.00s)
      // → PASS
      

      Wenn es HTTP sein muss: httptest.NewServer

      Nicht alles lässt sich hinter ein eigenes Interface verstecken — manchmal testen wir Code, der direkt mit http.Client arbeitet, etwa einen SDK-artigen Client für eine Versand-API. Auch hier braucht es keine echte Gegenstelle: httptest.NewServer startet einen echten HTTP-Server auf 127.0.0.1 mit von uns kontrollierten Antworten. Der getestete Code merkt nicht, dass er gegen unseren Fake redet.

      // shipping/shipping_test.go
      package shipping
      
      import (
      	"net/http"
      	"net/http/httptest"
      	"testing"
      )
      
      func TestClientReturnsErrorOn500(t *testing.T) {
      	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      		w.WriteHeader(http.StatusInternalServerError)
      	}))
      	defer srv.Close() // innerhalb des Tests ist defer korrekt
      
      	if err := FetchRates(srv.Client(), srv.URL); err == nil {
      		t.Fatal("erwartete einen Fehler bei HTTP 500, bekam nil")
      	}
      	// → --- PASS: TestClientReturnsErrorOn500 (0.00s)
      }
      

      Die Regel für den Einsatz ist einfach: Ein Fake ersetzt eine Abhängigkeit hinter einem eigenen Interface, wenn wir unser Verhalten testen. Ein httptest-Server simuliert eine echte Gegenstelle, wenn wir das HTTP-Verhalten selbst testen — Timeouts, Statuscodes, Retries. Beides zusammen deckt nahezu jeden Fall ab, in dem andere Ökosysteme zu schwergewichtigen Mocking-Frameworks greifen.

      ⚠ Häufiger Fehler: Das Interface neben die große Implementierung legen — etwa StripeClient mit zwölf Methoden, nur um „mocken zu können“. Der Fake muss dann alle zwölf Methoden implementieren, obwohl der Test nur Charge braucht. In Go gilt: das Interface dort definieren, wo es konsumiert wird, und so klein schneiden, dass ein Fake aus drei Zeilen besteht.

      ✅ Wichtige Erkenntnisse

      Haken setzen, um deinen Lernfortschritt zu markieren:

        44

        Benchmarks & pprof: Messen statt Raten

        Lektion 44 von 100

        Der Streit, den ein Benchmark beendet

        Zwei Behauptungen über denselben Code: „String-Konkatenierung mit += ist in der Schleife viel zu langsam, nimm strings.Builder!“ — „Quatsch, der Compiler optimiert das längst.“ Beide berufen sich auf Blogposts von 2019 und fremde Messungen. In Go endet diese Diskussion in zwei Minuten, weil das testing-Paket Benchmarks gleich mitliefert: Eine Funktion mit der Signatur BenchmarkXxx(b *testing.B), ausgeführt mit go test -bench, misst den eigenen Code auf der eigenen Maschine.

        Das Muster ist immer gleich: Der zu messende Code läuft in einer Schleife über b.N Iterationen. b.N setzt das Framework selbst — es erhöht die Iterationszahl so lange, bis die Messung stabil ist. Wir schreiben also nie selbst vor, wie oft gemessen wird.

        b.N ist Kalibrierung, nicht Vorgabe

        Das Framework startet mit kleinem b.N, misst und verdoppelt nach, bis die Gesamtzeit verlässlich ist. Deshalb muss die Schleife zwingend über b.N laufen — eine feste Zahl würde die Messung verfälschen. b.ResetTimer() wirft die Zeit für teures Setup vor der Schleife aus der Messung raus, b.ReportAllocs() (oder das Flag -benchmem) zeigt Speicher-Allokationen — oft der eigentliche Flaschenhals.

        Hier der Vergleich der beiden strittigen Varianten — mit einer Paket-Variablen sink, damit der Compiler das Ergebnis nicht wegoptimieren kann:

        // render/render_test.go
        package render
        
        import (
        	"strings"
        	"testing"
        )
        
        // sink verhindert, dass der Compiler die Berechnung als ungenutzt entfernt.
        var sink string
        
        func BenchmarkConcatPlus(b *testing.B) {
        	parts := []string{"<html>", "<body>", "<main>", "</main>", "</body>", "</html>"}
        	b.ResetTimer()
        	for i := 0; i < b.N; i++ {
        		var s string
        		for _, p := range parts {
        			s += p
        		}
        		sink = s
        	}
        }
        
        func BenchmarkBuilder(b *testing.B) {
        	parts := []string{"<html>", "<body>", "<main>", "</main>", "</body>", "</html>"}
        	b.ResetTimer()
        	for i := 0; i < b.N; i++ {
        		var sb strings.Builder
        		for _, p := range parts {
        			sb.WriteString(p)
        		}
        		sink = sb.String()
        	}
        }
        
        // Terminal: go test -bench=Builder ./render
        // → BenchmarkBuilder-8   11584226    103.7 ns/op    56 B/op   1 allocs/op
        
        // Terminal: go test -bench=. -benchmem ./render
        // → BenchmarkConcatPlus-8     2062662    583.2 ns/op   216 B/op   8 allocs/op
        // → BenchmarkBuilder-8       11584226    103.7 ns/op    56 B/op   1 allocs/op
        //
        // Lesart: pro Operation 583 vs. 104 Nanosekunden — der Builder ist
        // hier rund 5,6x schneller und verursacht 8x weniger Allokationen.
        

        Die Zahlen sind sofort aussagekräftig: ns/op ist die Zeit pro Iteration, B/op der Speicherbedarf pro Iteration, allocs/op die Zahl der Heap-Allokationen. Bei einem Request-Handler, der 10.000-mal pro Sekunde läuft, entscheidet genau diese Spalte über CPU-Last und Garbage-Collector-Druck.

        pprof:Wo die Zeit wirklich bleibt

        Ein Benchmark sagt, dass etwas langsam ist — aber nicht, warum. Dafür nimmt go test direkt ein CPU-Profil auf. Mit -cpuprofile wird bei den Benchmark-Läufen mitgeschrieben, in welchen Funktionen die Zeit verbracht wird; go tool pprof liest das Profil und sortiert die heißesten Funktionen nach oben.

        // Terminal: Profil aufnehmen und auswerten
        //
        //	go test -bench=. -cpuprofile=cpu.out ./render
        //	go tool pprof -top cpu.out
        //
        // → Showing nodes accounting for 890ms, 89.00% of 1000ms total
        // →       flat  flat%   sum%        cum   cum%  Function
        // →      520ms 52.00%  52.00%      520ms 52.00%  render.ConcatPlus
        // →      180ms 18.00%  70.00%      310ms 31.00%  runtime.growslice
        

        Das flat-Feld zeigt die Zeit in der Funktion selbst, cum die Zeit inklusive aller aufgerufenen Funktionen. Die Zeile runtime.growslice ist hier der Tipp des Profilers: Jedes += auf einen String allokiert einen neuen, immer größeren Buffer — exakt die Vermutung von vorhin, jetzt mit Zahlen belegt. Wer vertieft einsteigen will, ruft go tool pprof cpu.out interaktiv auf (top, list Funktionsname) und sieht die Zeit pro Quellcode-Zeile.

        ⚠ Häufiger Fehler: Das Ergebnis der gemessenen Berechnung nicht verwenden. Der Go-Compiler entfernt ungenutzte Berechnungen gnadenlos — wer den zusammengebauten String keiner Variablen zuweist, benchmarkt einen leeren Loop und bekommt traumhafte, bedeutungslose Nanosekunden. Immer an eine Paket-Variable (sink) zuweisen oder das Ergebnis validieren.

        ✅ Wichtige Erkenntnisse

        Haken setzen, um deinen Lernfortschritt zu markieren:

          45

          Fuzzing & der Race Detector

          Lektion 45 von 100

          Zwei stille Killer

          Tests prüfen Eingaben, an die wir gedacht haben. Die Fehler, die Produktionssysteme nachts wecken, kommen fast immer von zweierlei Art: Eingaben, an die niemand gedacht hat — ein Parser, der auf "12x" oder einem Emoji-String panikt — und Nebenläufigkeitsfehler, die nur auftreten, wenn zwei Goroutines zur falschen Millisekunde dasselbe Feld anfassen. Für beide hat Go seit Version 1.18 beziehungsweise 1.1 eingebaute Antworten: Fuzzing und den Race Detector.

          Starten wir mit Fuzzing. Ein Fuzz-Test ist wie ein Table-driven Test, nur dass die Tabelle vom Framework gefüllt wird: Go generiert systematisch Eingaben — orientiert an Code-Abdeckung, nicht rein zufällig — und ruft damit unsere Funktion auf. Unsere Aufgabe ist es nicht, das erwartete Ergebnis anzugeben, sondern eine Eigenschaft (Invariante) zu prüfen, die für jede Eingabe gelten muss: kein Panic, keine negativen Werte, Roundtrips bleiben erhalten.

          Fuzzing prüft Eigenschaften, nicht erwartete Werte

          Ein Unit-Test fragt: Was kommt bei dieser Eingabe heraus? Ein Fuzz-Test fragt: Was darf bei keiner Eingabe passieren? Konkret: ParseDuration darf Fehler zurückgeben, aber niemals paniken und niemals ein negatives Ergebnis liefern. Verletzt eine generierte Eingabe diese Invariante, stoppt der Lauf und schreibt den Übeltäter als Datei ins testdata-Verzeichnis — ab dann ist er ein dauerhafter Regressionstest im normalen go test.

          // duration/duration_test.go
          package duration
          
          import "testing"
          
          // ParseDuration akzeptiert Formate wie "90s" oder "1h30m" — und panikt nie.
          func FuzzParseDuration(f *testing.F) {
          	// Seed-Korpus: typische Formate, Grenzfälle und frühere Crashes
          	f.Add("90s")
          	f.Add("1h30m")
          	f.Add("")
          	f.Add("12x")
          
          	f.Fuzz(func(t *testing.T, input string) {
          		d, err := ParseDuration(input)
          		if err != nil {
          			return // Fehler sind ausdrücklich erlaubt — Panics nicht
          		}
          		if d < 0 {
          			t.Errorf("ParseDuration(%q) = %v — negativ ist nie erlaubt", input, d)
          		}
          	})
          }
          
          // Terminal: go test ./duration — ohne -fuzz laufen nur die Seed-Fälle
          // → ok  	duration	0.018s
          
          // Terminal: go test -fuzz=. -fuzztime=10s ./duration
          // → fuzz: elapsed: 2s, gathering baseline coverage: 0/192 completed
          // → fuzz: elapsed: 5s, execs: 210432 (42086/sec), new interesting: 9 (total 12)
          // → ---
          // → FAIL: FuzzParseDuration
          // →     Failing input written to testdata/fuzz/FuzzParseDuration/6e5f8c4b
          // → ab jetzt prüft go test diese Datei bei jedem Lauf mit
          

          Zwei Dinge machen dieses Werkzeug so praktisch: Die Seeds aus f.Add sind gleichzeitig Dokumentation valider Formate, und ein gefundener Crash führt zu einer Datei, die der normale go test-Lauf automatisch als Testfall übernimmt. Der Bug ist also ab dem Fund für immer abgesichert.

          Der Race Detector: Was go test -race sieht

          Jetzt zur zweiten Fehlerklasse. Ein Zähler, den vier Goroutinen hochzählen, sieht harmlos aus — und fällt ohne -race meistens sogar grün, weil sich die überlappenden Zugriffe nur manchmal treffen. Genau das macht Data Races so gefährlich: Sie sind nicht deterministisch und zeigen sich typischerweise unter echter Last in Produktion.

          // counter/counter_test.go — Version mit ungeschütztem n++
          package counter
          
          import (
          	"sync"
          	"testing"
          )
          
          func TestCounterParallel(t *testing.T) {
          	var n int
          
          	var wg sync.WaitGroup
          	for i := 0; i < 4; i++ {
          		wg.Add(1)
          		go func() {
          			defer wg.Done()
          			for j := 0; j < 1000; j++ {
          				n++ // Data Race: Schreiben von vier Goroutinen ohne Synchronisation
          			}
          		}()
          	}
          	wg.Wait()
          
          	// Ohne Synchronisation schwankt das Ergebnis von Lauf zu Lauf:
          	// → n = 3742, 3891, 4000 — Updates gehen beim Überlagern verloren
          
          	if n != 4000 {
          		t.Errorf("n = %d, wollte 4000 — verlorene Updates", n)
          	}
          }
          
          // Terminal: go test -race ./counter
          // → ==================
          // → WARNING: DATA RACE
          // → Read at 0x00c000014a09 by goroutine 8:
          // →   counter.TestCounterParallel.func1()
          // →       counter/counter_test.go:16 +0x3a
          // → Previous write at 0x00c000014a09 by goroutine 7:
          // →   counter.TestCounterParallel.func1()
          // →       counter/counter_test.go:16 +0x50
          // → FAIL
          

          Der Detector meldet nicht nur den Konflikt, sondern zeigt beide Zugriffe mit Datei, Zeile und Goroutine. Die Reparatur ist dann Standardwissen aus Modul 7: ein sync.Mutex um den kritischen Abschnitt oder — bei simplen Zählern — sync/atomic mit atomic.AddInt64. Der Test von oben bleibt unverändert und verifiziert die Reparatur: Mit Synchronisation kommt zuverlässig 4000 heraus.

          ⚠ Häufiger Fehler: go test in der CI ohne -race laufen zu lassen. Der Race Detector ist kein statischer Check, sondern instrumentiert den Build zur Laufzeit — er erkennt nur Zugriffe, die während dieses Laufs tatsächlich gleichzeitig passieren. Ein Race, der im normalen Lauf durchrauscht, bleibt unsichtbar. Für nebenläufigen Code sollte go test -race ./... der Standard in jeder Pipeline sein — die 2- bis 5-fach längere Laufzeit ist der Preis für deterministische Abstürze statt nächtlicher Wunder.

          Modul 9 im Rückblick

          Damit ist der Werkzeugkasten komplett, mit dem Go-Code nicht nur funktioniert, sondern beweist, dass er funktioniert: Tabellen machen Fallabdeckung billig, Helper machen Tests sauber, Interfaces machen Abhängigkeiten austauschbar, Benchmarks machen Performance diskutierbar, und Fuzzing plus Race Detector jagen die Fehler, vor denen Unit-Tests blind sind. Wer diese fünf Werkzeuge in den Workflow aufnimmt — Tabellen statt Kopieren, -race in der CI, -benchmem bei Performance-Fragen —, dessen Module bleiben auch dann stabil, wenn Produktionslast kommt.

          ✅ Wichtige Erkenntnisse

          Haken setzen, um deinen Lernfortschritt zu markieren:

            This site uses essential cookies for Stripe payments. No tracking cookies.