Tests, Benchmarks und Werkzeuge

// mathe/mathe.go
package mathe

func Addiere(a, b int) int { return a + b }

func Teile(a, b int) (int, error) {
    if b == 0 {
        return 0, ErrDivisionDurchNull
    }
    return a / b, nil
}

// mathe/mathe_test.go
package mathe

import "testing"

func TestAddiere(t *testing.T) {
    if got := Addiere(2, 3); got != 5 {
        t.Errorf("Addiere(2, 3) = %d, erwartet 5", got)
    }
}

func TestTeileDurchNull(t *testing.T) {
    _, err := Teile(1, 0)
    if err == nil {
        t.Fatal("Fehler erwartet")
    }
}

go test ./...            # alle Tests
go test -v ./...         # ausführlich
go test -run Addiere     # nur passende Tests
go test -race ./...      # mit Datenwettlauf-Erkennung
go test -cover ./...     # Testabdeckung

func TestIstPalindrom(t *testing.T) {
    tests := []struct {
        name     string
        eingabe  string
        erwartet bool
    }{
        {"einfach", "Anna", true},
        {"mit Leerzeichen", "Ein Esel lese nie", true},
        {"kein Palindrom", "Hallo", false},
        {"leer", "", true},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := IstPalindrom(tt.eingabe); got != tt.erwartet {
                t.Errorf("IstPalindrom(%q) = %v, erwartet %v", tt.eingabe, got, tt.erwartet)
            }
        })
    }
}

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func IstPalindrom(s string) bool {
    var r []rune
    for _, c := range strings.ToLower(s) {
        if unicode.IsLetter(c) || unicode.IsDigit(c) {
            r = append(r, c)
        }
    }
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        if r[i] != r[j] {
            return false
        }
    }
    return true
}

func main() {
    tests := []struct {
        name     string
        eingabe  string
        erwartet bool
    }{
        {"einfach", "Anna", true},
        {"mit Leerzeichen", "Ein Esel lese nie", true},
        {"kein Palindrom", "Hallo", false},
        {"leer", "", true},
    }
    fehler := 0
    for _, tt := range tests {
        got := IstPalindrom(tt.eingabe)
        status := "OK    "
        if got != tt.erwartet {
            status = "FEHLER"
            fehler++
        }
        fmt.Printf("%s %s\n", status, tt.name)
    }
    fmt.Println(fehler, "Fehler")
}

func ExampleAddiere() {
    fmt.Println(Addiere(2, 3))
    // Output: 5
}

func BenchmarkAddiere(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Addiere(2, 3)
    }
}
// go test -bench=. -benchmem

func FuzzIstPalindrom(f *testing.F) {
    f.Add("Anna")
    f.Fuzz(func(t *testing.T, s string) {
        IstPalindrom(s)                // darf nie abstürzen
    })
}
// go test -fuzz=Fuzz

package main

import "fmt"

type Speicher interface {
    Lade(schluessel string) (string, bool)
}

type FakeSpeicher map[string]string

func (f FakeSpeicher) Lade(k string) (string, bool) { v, ok := f[k]; return v, ok }

func Begruessung(s Speicher, id string) string {
    if name, ok := s.Lade(id); ok {
        return "Hallo " + name
    }
    return "Hallo Fremder"
}

func main() {
    fake := FakeSpeicher{"1": "Mia"}
    fmt.Println(Begruessung(fake, "1"), "|", Begruessung(fake, "2"))
}