How to use coverage tool in Golang unit testing?

Use the go test -cover command in Go unit testing to measure coverage and specify the -cover or -coverprofile option to generate the results; the -covermode option sets the coverage mode (set, count, or atomic). Practical cases demonstrate how to write tests and generate coverage reports using coverage configuration files and the go tool cover command.

How to use coverage tool to test coverage in Golang unit testing

Coverage tool is very important in unit testing because it Can help you identify untested parts of your code. This is critical to ensure the quality and reliability of your code. In Golang, you can use the go test -cover command to measure coverage in unit tests.

Install the coverage tool

To use the coverage tool in Golang, you need to install it. You can install it using the following command:

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

Measure coverage

To measure the coverage of unit tests, use the go test command and Specify the -cover flag. This flag can then accept the following values:

• -cover: Displays coverage results, including uncovered lines, files, and packages.
• -coverprofile=profile.out: Write the coverage results to the specified file. This is useful for further analysis or use with other tools.

• -covermode=mode: Set the coverage mode. Acceptable values ​​include:

  • #set: Use set mode to report coverage. It will assign a counter to each covered line of code and generate a report after the test is completed.
  • count: Use count mode to report coverage. It will assign a boolean value to each covered line of code and generate a report after the test is completed.
  • atomic: Report coverage using atomic counting mode. It will assign an int64 counter to each covered line of code and generate a report after the test is completed.

Practical case

The following is a brief example demonstrating how to measure coverage in Golang unit testing:

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)
        }
    })
}

Execute the following command at the command line to generate a coverage report:

go test -test.coverprofile=coverage.out

This will create a coverage report in the coverage.out file. You can view the report using the go tool cover command:

go tool cover -html=coverage.out

This will open an HTML report in your browser showing the lines of code and files that were not covered.

The above is the detailed content of How to use coverage tool in Golang unit testing?. For more information, please follow other related articles on the PHP Chinese website!