Stratégies de gestion des erreurs pour les tests unitaires de la fonction Go

Dans les tests unitaires de la fonction Go, il existe deux stratégies principales pour la gestion des erreurs : 1. Représenter l'erreur comme une valeur spécifique du type d'erreur, qui est utilisée pour affirmer la valeur attendue ; 2. Utiliser des canaux pour transmettre les erreurs à la fonction de test ; , ce qui convient pour tester le code concurrent. Dans un cas pratique, utilisez la stratégie de valeur d'erreur pour vous assurer que la fonction renvoie 0 pour une entrée négative.

Stratégie de gestion des erreurs pour les tests unitaires des fonctions Go

Les tests unitaires sont une étape importante pour garantir la robustesse et la fiabilité de votre code. Dans Go, les tests unitaires peuvent être effectués à l'aide du package testing, qui contient plusieurs stratégies de gestion des erreurs. testing 包来执行单元测试，其中包含处理错误的几种策略。

错误处理策略

Go 中有两种处理错误的主要策略：

1. 错误值

将错误表示为 error

Stratégies de gestion des erreurs

Il existe deux stratégies principales pour gérer les erreurs dans Go :

1 Les valeurs d'erreur

Représentent les erreurs sous forme de valeurs spécifiques de type erreur. Pour utiliser cette méthode dans les tests unitaires, vous pouvez affirmer les erreurs aux valeurs attendues :

func TestMyFunction(t *testing.T) {
    err := myFunction()
    if err != nil {
        t.Errorf("myFunction returned an unexpected error: %v", err)
    }
}

2 Canaux d'erreur

🎜🎜Utilisez des canaux pour transmettre les erreurs aux fonctions de test. Ceci est utile pour tester du code concurrent, car plusieurs erreurs peuvent être observées en même temps : 🎜

func TestMyConcurrentFunction(t *testing.T) {
    done := make(chan error)
    go func() { done <- myConcurrentFunction() }()
    select {
    case err := <-done:
        if err != nil {
            t.Errorf("myConcurrentFunction returned an unexpected error: %v", err)
        }
    case <-time.After(time.Second):
        t.Errorf("myConcurrentFunction did not complete within the timeout")
    }
}

🎜 Exemple pratique 🎜🎜 Considérez la fonction suivante, qui ajoute des nombres dans une tranche : 🎜

func sum(numbers []int) int {
    total := 0
    for _, num := range numbers {
        if num < 0 {
            return 0
        }
        total += num
    }
    return total
}

🎜 Les tests unitaires utilisant la stratégie de valeur d'erreur garantissent que la fonction Renvoie 0 pour une entrée négative : 🎜

func TestSum(t *testing.T) {
    tests := []struct {
        input  []int
        result int
    }{
        {[]int{1, 2, 3}, 6},
        {[]int{0, 0, 0}, 0},
        {[]int{-1, 0, 1}, 0},
    }

    for _, test := range tests {
        result := sum(test.input)
        if result != test.result {
            t.Errorf("sum(%v) returned %d, expected %d", test.input, result, test.result)
        }
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!