Wie verwende ich das Coverage-Tool beim Golang-Unit-Test?

Verwenden Sie den Befehl go test -cover, um die Abdeckung in Go-Komponententests zu messen, und geben Sie die Option -cover oder -coverprofile an, um die Ergebnisse zu generieren. Die Option -covermode legt den Abdeckungsmodus fest (set, count oder atomic). In praktischen Fällen wird gezeigt, wie Sie mithilfe von Coverage-Konfigurationsdateien und dem Befehl go tool cover Tests schreiben und Coverage-Berichte erstellen.

So verwenden Sie das Coverage-Tool zum Testen der Coverage beim Golang-Unit-Testen

Das Coverage-Tool ist beim Unit-Testen sehr wichtig, da es Ihnen hilft, die ungetesteten Teile Ihres Codes zu identifizieren. Dies ist entscheidend, um die Qualität und Zuverlässigkeit Ihres Codes sicherzustellen. In Golang können Sie den Befehl go test -cover verwenden, um die Abdeckung in Komponententests zu messen. 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

Abdeckungstool installieren

🎜🎜Um das Abdeckungstool in Golang zu verwenden, müssen Sie es installieren. Sie können es mit dem folgenden Befehl installieren: 🎜

go tool cover -html=coverage.out

🎜🎜Abdeckung messen🎜🎜🎜Um die Abdeckung von Komponententests zu messen, verwenden Sie den Befehl go test und geben Sie die -cover an Flagge . Dieses Flag kann dann die folgenden Werte annehmen: 🎜

• 🎜-cover🎜: Zeigt Abdeckungsergebnisse an, einschließlich nicht abgedeckter Leitungen, Dateien und Pakete.
• 🎜-coverprofile=profile.out🎜: Schreiben Sie die Coverage-Ergebnisse in die angegebene Datei. Dies ist für die weitere Analyse oder die Verwendung mit anderen Tools nützlich.
• 🎜🎜-covermode=mode🎜: Legt den Abdeckungsmodus fest. Zu den zulässigen Werten gehören: 🎜
  • 🎜set🎜: Verwenden Sie den Set-Modus, um die Abdeckung zu melden. Es weist jeder abgedeckten Codezeile einen Zähler zu und generiert nach Abschluss des Tests einen Bericht.
  • 🎜Zählung🎜: Verwenden Sie den Zählmodus, um die Abdeckung zu melden. Es weist jeder abgedeckten Codezeile einen booleschen Wert zu und generiert nach Abschluss des Tests einen Bericht.
  • 🎜atomar🎜: Berichten Sie die Abdeckung im atomaren Zählmodus. Es weist jeder abgedeckten Codezeile einen int64-Zähler zu und generiert nach Abschluss des Tests einen Bericht.

🎜🎜Praktischer Fall🎜🎜🎜Hier ist ein kurzes Beispiel, das zeigt, wie die Abdeckung in Golang-Unit-Tests gemessen wird: 🎜🎜🎜main.go🎜🎜rrreee🎜🎜 main_test .go🎜🎜rrreee🎜Führen Sie den folgenden Befehl in der Befehlszeile aus, um einen Abdeckungsbericht zu erstellen: 🎜rrreee🎜Dadurch wird ein Abdeckungsbericht in der Datei coverage.out erstellt. Sie können den Bericht mit dem Befehl go tool cover anzeigen: 🎜rrreee🎜Dadurch wird ein HTML-Bericht in Ihrem Browser geöffnet, der die Zeilen und Dateien anzeigt, die nicht abgedeckt wurden. 🎜

Das obige ist der detaillierte Inhalt vonWie verwende ich das Coverage-Tool beim Golang-Unit-Test?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!