Stratégies de gestion des erreurs dans les tests de fonctions Golang

Les stratégies de gestion des erreurs dans les tests de fonction Go incluent : l'utilisation du package d'erreurs intégré pour créer et gérer les erreurs. Personnalisez les types d’erreurs pour fournir des informations d’erreur plus spécifiques. Vérifiez de manière concise les conditions d’erreur à l’aide d’assertions d’assertion. Utilisez Fatal et Skip pour terminer ou ignorer les tests sur les erreurs critiques.

Stratégie de gestion des erreurs dans les tests de fonction Go

Dans les tests de fonction Go, la gestion correcte des erreurs est cruciale pour garantir la fiabilité et la robustesse du test. Voici quelques stratégies pratiques :

1. Utilisez le package errors intégré errors 包

Go 的标准库提供了 errors 包，它提供了创建和管理错误的机制。错误值可以实现 error 接口，使我们能够轻松地使用 if 条件来处理错误。

import (
    "fmt"
    "errors"
)

func Divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func TestDivide(t *testing.T) {
    result, err := Divide(10, 2)
    if err != nil {
        t.Error(err)
    }
    fmt.Println(result) // 输出：5
}

2. 自定义错误类型

有时，使用自定义错误类型比使用内置错误更合适。这样可以提供更具体和有意义的错误信息。

type MyError struct {
    Message string
}

func (e MyError) Error() string {
    return e.Message
}

func SomeFunction() error {
    return MyError{Message: "an error occurred"}
}

func TestSomeFunction(t *testing.T) {
    err := SomeFunction()
    if err != nil {
        t.Errorf("an error occurred: %v", err)
    }
}

3. 使用 assert 断言

Go 的 testing 包提供了 assert 断言，可以帮助我们检查错误条件。它们提供了一种简洁的方式来编写错误检查代码。

import "testing"

func TestDivide(t *testing.T) {
    result, err := Divide(10, 2)
    if err := assert.NoError(err); err != nil {
        t.Error(err)
    }
    fmt.Println(result) // 输出：5
}

4. 使用 Fatal 和 Skip

在某些情况下，当遇到严重错误时，我们可能需要终止测试。testing 包提供了 Fatal 和 Skip 函数来实现此目的。

func TestDivide(t *testing.T) {
    result, err := Divide(10, 0)
    if err != nil {
        t.Fatal(err)
    }
    fmt.Println(result) // 输出：0 (不会执行)
}

实战案例

让我们考虑一个需要处理错误的函数测试的示例：

import (
    "testing"
    "errors"
)

func MyFunction(input string) (string, error) {
    if input == "" {
        return "", errors.New("input cannot be empty")
    }
    return input + " processed", nil
}

func TestMyFunction(t *testing.T) {
    testCases := []struct {
        input    string
        expected string
        err      error
    }{
        {input: "abc", expected: "abc processed", err: nil},
        {input: "", expected: "", err: errors.New("input cannot be empty")},
    }

    for _, tc := range testCases {
        result, err := MyFunction(tc.input)
        if !errors.Is(err, tc.err) {
            t.Errorf("expected error %v, got %v", tc.err, err)
        }
        if result != tc.expected {
            t.Errorf("expected %v, got %v", tc.expected, result)
        }
    }
}

在这个例子中，我们使用 testCases 表驱动测试来覆盖不同的输入场景。我们使用 errors.Is 来比较实际错误与预期的错误。同样，我们使用 if

🎜La bibliothèque standard de Go fournit le package errors, qui permet la création et la gestion des erreurs. .Mécanismes. Les valeurs d'erreur peuvent implémenter l'interface error, nous permettant d'utiliser facilement les conditions if pour gérer les erreurs. 🎜rrreee🎜🎜2. Types d'erreurs personnalisés🎜🎜🎜 Parfois, il est plus approprié d'utiliser des types d'erreurs personnalisés plutôt que des erreurs intégrées. Cela fournit des informations d’erreur plus spécifiques et significatives. 🎜rrreee🎜🎜3. Utilisez les assertions assert🎜🎜🎜Le package testing de Go fournit des assertions assert qui peuvent nous aider à vérifier les conditions d'erreur. Ils fournissent un moyen concis d’écrire du code de vérification des erreurs. 🎜rrreee🎜🎜4. Utilisez Fatal et Skip🎜🎜🎜Dans certains cas, nous devrons peut-être mettre fin au test lorsqu'une erreur grave est rencontrée. Le package testing fournit les fonctions Fatal et Skip à cet effet. 🎜rrreee🎜🎜Cas pratique🎜🎜🎜Considérons un exemple de test de fonction qui doit gérer les erreurs : 🎜rrreee🎜Dans cet exemple, nous utilisons des tests pilotés par des tables testCases pour couvrir différents scénarios d'entrée. Nous utilisons errors.Is pour comparer les erreurs réelles avec les erreurs attendues. Encore une fois, nous utilisons les conditions if pour gérer les erreurs et garantir que les résultats sont comme prévu. 🎜

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!