Comment utiliser l'outil de couverture dans les tests unitaires Golang ?

Utilisez la commande go test -cover pour mesurer la couverture dans les tests unitaires Go et spécifiez l'option -cover ou -coverprofile pour générer les résultats ; l'option -covermode définit le mode de couverture (ensemble, nombre ou atomique). Des cas pratiques montrent comment rédiger des tests et générer des rapports de couverture à l'aide des fichiers de configuration de couverture et de la commande go tool cover.

Comment utiliser l'outil de couverture pour tester la couverture dans les tests unitaires Golang

L'outil de couverture est très important dans les tests unitaires car il vous aide à identifier les parties non testées de votre code. Ceci est crucial pour garantir la qualité et la fiabilité de votre code. Dans Golang, vous pouvez utiliser la commande go test -cover pour mesurer la couverture dans les tests unitaires. go test -cover 命令来测量单元测试中的覆盖率。

安装覆盖工具

要在 Golang 中使用覆盖工具，您需要安装它。您可以使用以下命令进行安装：

go install golang.org/x/tools/cmd/cover

测量覆盖率

要测量单元测试的覆盖率，请使用 go test 命令并指定 -cover 标志。该标志随后可以接受以下值：

• -cover：显示覆盖结果，包括未覆盖的行、文件和包。
• -coverprofile=profile.out：将覆盖结果写入指定的文件中。这对于进一步分析或与其他工具一起使用很有用。

• -covermode=mode：设置覆盖模式。可接受的值包括：

  • set：使用 set 模式报告覆盖情况。它将为每个被覆盖的代码行分配一个计数器，并在测试完成后生成报告。
  • count：使用 count 模式报告覆盖情况。它将为每个被覆盖的代码行分配一个 boolean 值，并在测试完成后生成报告。
  • atomic：使用原子计数模式报告覆盖情况。它将为每个被覆盖的代码行分配一个 int64 计数器，并在测试完成后生成报告。

实战案例

以下是一个演示如何测量 Golang 单元测试中覆盖率的简要示例：

main.go

package main

import (
    "fmt"
    "strconv"
)

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

// Convert a string to a number
func StrToInt(s string) int {
    n, err := strconv.Atoi(s)
    if err != nil {
        fmt.Println(err.Error())
        return 0
    }
    return n
}

main_test.go

package main

import (
    "testing"
)

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

    for _, tt := range tests {
        t.Run(fmt.Sprintf("TestAdd%d_%d", tt.a, tt.b), func(t *testing.T) {
            if got := Add(tt.a, tt.b); got != tt.want {
                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.want)
            }
        })
    }
}

func TestStrToInt(t *testing.T) {
    tests := []struct {
        s string
        want int
    }{
        {"1", 1},
        {"0", 0},
        {"-1", -1},
    }

    for _, tt := range tests {
        t.Run(fmt.Sprintf("TestStrToInt%s", tt.s), func(t *testing.T) {
            if got := StrToInt(tt.s); got != tt.want {
                t.Errorf("StrToInt(%s) = %d, want %d", tt.s, got, tt.want)
            }
        })
    }
}

func TestCoverage(t *testing.T) {
    t.Run("Add", func(t *testing.T) {
        coverProfile := "add_coverage.out"
        args := []string{"-test.coverprofile=" + coverProfile, "-test.covermode=set"}
        cmd := exec.Command("go", "test", args...)
        if err := cmd.Run(); err != nil {
            t.Fatalf("Could not run coverage test: %v", err)
        }
    })

    t.Run("StrToInt", func(t *testing.T) {
        coverProfile := "str_int_coverage.out"
        args := []string{"-test.coverprofile=" + coverProfile, "-test.covermode=set"}
        cmd := exec.Command("go", "test", args...)
        if err := cmd.Run(); err != nil {
            t.Fatalf("Could not run coverage test: %v", err)
        }
    })
}

在命令行中执行以下命令以生成覆盖率报告：

go test -test.coverprofile=coverage.out

这将在 coverage.out 文件中创建一个覆盖率报告。您可以使用 go tool cover

Installer l'outil de couverture

🎜🎜Pour utiliser l'outil de couverture dans Golang, vous devez l'installer. Vous pouvez l'installer à l'aide de la commande suivante : 🎜

go tool cover -html=coverage.out

🎜🎜Measuring Coverage🎜🎜🎜Pour mesurer la couverture des tests unitaires, utilisez la commande go test et spécifiez le -cover drapeau . Cet indicateur peut alors accepter les valeurs suivantes : 🎜

• 🎜-cover🎜 : affiche les résultats de couverture, y compris les lignes, fichiers et packages non couverts.
• 🎜-coverprofile=profile.out🎜 : Écrivez les résultats de couverture dans le fichier spécifié. Ceci est utile pour une analyse plus approfondie ou pour une utilisation avec d’autres outils.
• 🎜🎜-covermode=mode🎜 : Définissez le mode de couverture. Les valeurs acceptables incluent : 🎜
  • 🎜set🎜 : utilisez le mode défini pour signaler la couverture. Il attribuera un compteur à chaque ligne de code couverte et générera un rapport une fois le test terminé.
  • 🎜count🎜 : utilisez le mode comptage pour signaler la couverture. Il attribuera une valeur booléenne à chaque ligne de code couverte et générera un rapport une fois le test terminé.
  • 🎜atomic🎜 : rapportez la couverture en utilisant le mode de comptage atomique. Il attribuera un compteur int64 à chaque ligne de code couverte et générera un rapport une fois le test terminé.

🎜🎜Cas pratique🎜🎜🎜Voici un bref exemple démontrant comment mesurer la couverture dans les tests unitaires Golang : 🎜🎜🎜main.go🎜🎜rrreee🎜🎜 main_test .go🎜🎜rrreee🎜Exécutez la commande suivante sur la ligne de commande pour générer un rapport de couverture : 🎜rrreee🎜Cela créera un rapport de couverture dans le fichier coverage.out. Vous pouvez visualiser le rapport à l'aide de la commande go tool cover : 🎜rrreee🎜Cela ouvrira un rapport HTML dans votre navigateur affichant les lignes et les fichiers qui n'ont pas été couverts. 🎜

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!