Tests unitaires dans le cycle de vie des fonctions Golang

Les tests unitaires sont cruciaux pour garantir le comportement attendu des fonctions Golang. Cet article décrit les stratégies de tests unitaires à différentes étapes du cycle de vie d'une fonction : Initialisation et arrêt des tests : utilisez runtime.BeforeAlloc et runtime.AfterAlloc pour effectuer des opérations de configuration et de nettoyage avant et après l'allocation de mémoire. Signatures de fonction de test : utilisez la fonction Test du package de tests pour spécifier des cas de test par rapport à une signature de fonction spécifique. Couverture du code de test : utilisez l'indicateur -cover de la commande go test pour générer un rapport de couverture afin d'évaluer la couverture de test d'une fonction.

Tests unitaires dans le cycle de vie des fonctions Golang

Les tests unitaires sont essentiels pour garantir le comportement attendu des fonctions Golang sous différents chemins d'exécution. Cet article détaillera les stratégies d'exécution de tests unitaires à différentes étapes du cycle de vie des fonctions.

Test d'initialisation et de terminaison

Dans le cycle de vie de la fonction Golang, les fonctions runtime.BeforeAlloc et runtime.AfterAlloc fournies par le package runtime sont utilisé pour stocker les données en mémoire Un code d'initialisation et de terminaison spécifique est exécuté avant et après l'allocation. Ces fonctions peuvent être utilisées pour effectuer des opérations de configuration et de nettoyage des tests avant et après le début des tests unitaires. runtime.BeforeAlloc 和 runtime.AfterAlloc 函数用于在内存分配之前和之后执行特定的初始化和终止代码。这些函数可以用来在单元测试开始之前和结束之后执行测试设置和清理操作。

package main

import (
    "fmt"
    "runtime"
)

func main() {
    runtime.BeforeAlloc() // 执行测试前初始化

    // 测试代码

    runtime.AfterAlloc() // 执行测试后清理
}

测试函数签名

testing 包提供的 Test 函数可以用来对一个函数进行单元测试。Test 函数使用一个针对函数签名的测试名称来指定特定的测试用例。

package main

import (
    "testing"
)

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

func TestSum(t *testing.T) {
    tests := []struct {
        a, b int
        want int
    }{
        {1, 2, 3},
        {5, 10, 15},
        {-1, 10, 9},
    }

    for _, test := range tests {
        got := Sum(test.a, test.b)
        if got != test.want {
            t.Errorf("Sum(%d, %d) = %d, want %d", test.a, test.b, got, test.want)
        }
    }
}

func main() {
    testing.Main()
}

测试代码覆盖率

单元测试还用于衡量代码覆盖率，以确保函数已进行适当的测试。go test 命令可以使用 -cover 标志来生成覆盖率报告。

go test -cover

coverage:
  /path/to/package/func_test.go:62.5% (statements)

实战案例

测试一个简单的加法函数

考虑一个函数 Add，它将两个数字相加。以下单元测试确保了 Add 在不同的输入下正确计算求和：

package main

import (
    "testing"
)

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

func TestAdd(t *testing.T) {
    tests := []struct {
        a, b int
        want int
    }{
        {1, 2, 3},
        {5, 10, 15},
        {-1, 10, 9},
    }

    for _, test := range tests {
        got := Add(test.a, test.b)
        if got != test.want {
            t.Errorf("Add(%d, %d) = %d, want %d", test.a, test.b, got, test.want)
        }
    }
}

测试函数的初始化和终止

考虑一个函数 InitAndTerminate，它执行一些初始化并终止操作。以下单元测试使用 runtime.BeforeAlloc 和 runtime.AfterAlloc

package main

import (
    "fmt"
    "runtime"
    "testing"
)

func InitAndTerminate() {
    fmt.Println("Initializing...")

    runtime.BeforeAlloc() // 执行初始化操作

    fmt.Println("Terminating...")

    runtime.AfterAlloc() // 执行终止操作
    fmt.Println("Terminated.")
}

func TestInitAndTerminate(t *testing.T) {
    runtime.BeforeAlloc() // 触发自定义初始化

    InitAndTerminate()   // 执行被测函数

    runtime.AfterAlloc()  // 触发自定义终止
}

Test function signature

La fonction Test fournie par le package testing peut être utilisée pour tester unitairement une fonction. La fonction Test spécifie un scénario de test spécifique en utilisant un nom de test par rapport à la signature de la fonction.

rrreee

🎜Test Code Coverage🎜🎜🎜Les tests unitaires sont également utilisés pour mesurer la couverture du code afin de garantir que les fonctions sont correctement testées. La commande 🎜go test🎜 peut utiliser l'indicateur -cover pour générer des rapports de couverture. 🎜rrreee🎜🎜Cas pratique🎜🎜🎜🎜Test d'une fonction d'addition simple🎜🎜🎜Considérons une fonction Ajouter qui ajoute deux nombres. Le test unitaire suivant garantit que Add calcule correctement la somme sous différentes entrées : 🎜rrreee🎜🎜Test de l'initialisation et de la fin des fonctions 🎜🎜🎜Considérons une fonction InitAndTerminate qui exécute une certaine initialisation et les opérations de résiliation. Les tests unitaires suivants sont testés à l'aide de runtime.BeforeAlloc et runtime.AfterAlloc : 🎜rrreee🎜🎜Conclusion🎜🎜🎜En exécutant des tests unitaires à différentes étapes du cycle de vie de la fonction Golang , vous pouvez vous assurer que le comportement attendu de la fonction est vérifié sous tous les chemins d'exécution possibles. Les stratégies et les exemples pratiques abordés dans l'article fournissent un guide complet des tests unitaires dans Golang. 🎜

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!