golang testing test method

Go language is a fast, safe, and simple programming language that also supports testing and is very friendly. When developing and testing in Golang, it can improve the quality and accuracy of the code, making it easier for developers to iterate during project development.

This article will introduce the testing methods in Golang, including unit testing, benchmark testing, performance testing and boundary testing. We will share common test cases and testing techniques to help readers better understand Golang testing methods and skills, and improve development efficiency and quality.

1. Unit test

1. Basic framework of test cases

The basic framework of test cases is:

func TestFunctionName(t *testing.T) {
    // testing function
}

TestFunctionName is the name of the test method, which must start with It starts with Test, and the following FunctionName can be named arbitrarily. testing.T is a test context, used to schedule test access methods and record test status. It can be used to report failures and errors during testing and output test results to the console.

For example code:

package main

import "testing"

func Sum(x int, y int) int {
    return x + y
}

func TestSum(t *testing.T) {
    got := Sum(1, 2)
    want := 3

    if got != want {
        t.Errorf("Sum(1,2) = %d; want %d", got, want)
    }
}

When the program is running, if the output result is inconsistent with the expectation, an error message will be output, for example:

--- FAIL: TestSum (0.00s)
    main_test.go:11: Sum(1,2) = 4; want 3
FAIL
exit status 1
FAIL        command-line-arguments  0.005s

2. Test case naming and organization

Golang’s test method names must be prefixed with Test, which allows the test framework to automatically recognize them and execute them when running the go test command. At the same time, in order to avoid conflicts with other test methods with the same name, the naming of test methods should ensure uniqueness.

In order to better organize the test cases, you can add some identifiable identifiers in front of the test cases, such as:

• TestXxx, BenchmarkXxx, ExampleXxx When running the example in the browser Run the corresponding function, use Only this test method will be run in the test command. For example: TestParseShort()
• TestXxxParallel can run in parallel, and t.Parallel() can be used to improve efficiency in testing. For example: TestFooParallel()
• 3. Goals and implementation of test cases

Through unit testing, the quality and accuracy of Golang code can be verified, including:

Whether the function returns the expected result

• Whether it conforms to the runtime processing logic
• Whether it can handle unexpected situations
• For example code:

// Add 两个整数x和y
func Add(x, y int) int {
    return x + y
}

Corresponding test code:

func TestAdd(t *testing.T) {
    cases := []struct {
        in1, in2, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, c := range cases {
        got := Add(c.in1, c.in2)
        if got != c.want {
            t.Errorf("Add(%d, %d) == %d, want %d", c.in1, c.in2, got, c.want)
        }
    }
}

Go's testing framework allows us to create test cases with control structures, such as loops, branches, and exception error handling. In testing code, you verify that the code behaves as designed by passing input parameters to a function and comparing the function output value to the expected value.

2. Benchmark Test

Golang benchmark test is used to compare the performance differences of codes under different situations. Benchmarks run code multiple times and compare the running times. If there is a speed difference, you can determine which implementation is faster.

The basic framework of benchmark testing is:

func BenchmarkFunctionName(b *testing.B) {
    // Testing code
}

Among them, BenchmarkFunctionName represents the benchmark test method name, which must start with Benchmark, and the following FunctionName can be named arbitrarily. testing.B is the test context, used to control the status and iteration of the test. During benchmark testing, you can use it to control the number of test runs, detect errors that may occur when testing is stopped, and other issues.

For example code:

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(1, 2)
    }
}

When the program runs, the output result is as follows:

BenchmarkAdd-4        2000000000             0.29 ns/op
PASS
ok      _/Users/test/main    1.028s

Among them,

"BenchmarkAdd" represents the benchmark test The name

• "4" indicates the number of goroutines executed in parallel by the test function.
• "2000000000" indicates the total number of iterations executed by testing.B.Run. The internal adaptive balancing of each iteration in the Go language The times
• "0.29 ns/op" means that the average time required for each iteration is 0.29 nanoseconds.
• 3. Performance Test

Performance test is used to test the performance of the program during long-term operation. For example:

func TestPerfAdd(t *testing.T) {
    for i := 0; i < 100000; i++ {
        Add(1, 2)
    }
}

The test loop runs the function 100,000 times to test its performance issues when running for a long time. Ideal for testing how well a program performs against memory leaks, file handle leaks, or other resource leaks.

4. Boundary Testing

Boundary testing is used to test how well the code handles boundary conditions. For example:

func TestBubbleSort(t *testing.T) {
    tests := []struct {
        name string
        in   []int
        want []int
    }{
        {"Sorted", []int{1, 2, 3, 4, 5}, []int{1, 2, 3, 4, 5}},
        {"Reverse", []int{5, 4, 3, 2, 1}, []int{1, 2, 3, 4, 5}},
        {"FewElement", []int{5, 3}, []int{3, 5}},
        {"Duplicate", []int{5, 3, 5, 2, 2}, []int{2, 2, 3, 5, 5}},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            BubbleSort(tt.in)
            if !reflect.DeepEqual(tt.in, tt.want) {
                t.Errorf("test case %s expects %v but actual is %v",
                    tt.name, tt.want, tt.in)
            }
        })
    }
}

Boundary testing can check whether the program meets expectations when handling edge conditions. , for example:

Process some abnormal inputs (such as negative numbers, 0, maximum/minimum values)

• Let the program be in the fastest or slowest processing situation (such as The data size is 0 or the maximum value)
• Set upper and lower limits for various parameters of the function and test the reaction of the function
• Summary

When testing Golang code, the diversity of test cases should be considered to provide useful and comprehensive tests for various parts of the program. The Golang testing framework supports unit testing, benchmark testing, performance testing and boundary testing, and we can choose according to actual needs. Not only that, we also need to follow some testing best practices, such as standardizing test method naming, rationally allocating test tasks, extracting repeated test logic and making it easier to run tests quickly. I believe that after mastering these testing skills, readers will be able to conduct more in-depth code testing when developing Golang, and improve the testing efficiency and code quality of development.

The above is the detailed content of golang testing test method. For more information, please follow other related articles on the PHP Chinese website!