^-^
【go语言】Golang单元测试与性能分析
最近更新：2024-12-05   |   字数总计：2.9k   |   阅读估时：14分钟   |   阅读量：次
  1. Golang单元测试与性能分析
    1. 单元测试
    2. 单元测试-功能测试
    3. 单元测试-模糊测试
    4. 单元测试-基准（性能）测试
    5. 单元测试-http测试
    6. pprof性能分析工具
      1. 数据采集
        1. web数据采集
        2. 基准测试数据采集
        3. 硬编码数据采集
      2. 数据分析
        1. 命令行分析
          1. 对本地profile文件进行分析
          2. 对pprof网页结果进行分析
        2. Web分析

Golang单元测试与性能分析

单元测试

  1. 功能测试：输入预期的输入，是否能得到预期输出
  2. 模糊测试：输入不符合预期的入参，应用程序能否报错，健壮性的检查
  3. 基准（性能）测试，给定运行次数或运行市场，获取每次操作运行时长和内存分配
  4. http测试：httptest 模拟http请求，用于测试请求处理程序功能和性能
  • 规则
  1. 测试用例文件必须以_test结尾，例如：utilt_test.go
  2. 功能测试用例方法必须以Test开头
  3. 默认情况下测试用例若正常通过不会打印任何信息，可以通过—v来打印完整信息
  4. 声明后缀为“test”的包的测试文件将编译为分离包，然后与主测试二进制文件链接并运行
  5. go help test、go help testflag 可查看帮助
  • go test 模式
  1. 本地模式：编译运行当前目录中的测试用例，go test 或 go test—v
  2. 列表模式：编译并测试命令行上列出的每一个包，例如：go test util、go test./..、go test.等
  • TestMain
  1. 单元测试运行前，可通过这个函数做一些初始化工作
    1
    2
    3
    func TestMain(m *testing.M){
        m.Run()
    }

单元测试-功能测试

  • 被测试代码
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    package util

    import (
    	"regexp"
    	"strconv"
    	"strings"
    )

    const (
    	B = 1 << (iota * 10)
    	KB
    	MB
    	GB
    	TB
    	PB
    )

    const defaultNum = 100

    func ParseSize(size string) (int64, string) {
    	re, _ := regexp.Compile("[0-9]+")
    	unit := string(re.ReplaceAll([]byte(size), []byte("")))
    	num, _ := strconv.ParseInt(strings.Replace(size, unit, "", 1), 10, 64)
    	unit = strings.ToUpper(unit)
    	var byteNum int64 = 0
    	switch unit {
    	case "B":
    		byteNum = num
    	case "KB":
    		byteNum = num * KB
    	case "MB":
    		byteNum = num * MB
    	case "GB":
    		byteNum = num * GB
    	case "TB":
    		byteNum = num * TB
    	case "PB":
    		byteNum = num * PB
    	default:
    		num = 0
    	}

    	if num == 0 {

    		num = defaultNum
    		byteNum = num * MB
    		unit = "MB"

    	}
    	sizeStr := strconv.FormatInt(num, 10) + unit
    	return byteNum, sizeStr
    }

  • 功能测试代码 util_test.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    package util

    import "testing"

    var commTestData []commStruct

    type commStruct struct {
    	Group         string
    	SizeStr       string
    	ExpectSize    int64
    	ExpectSizeStr string
    }

    func initCommonData() {
    	commTestData = []commStruct{
    		{"B", "1b", B, "1B"},
    		{"B", "100b", 100 * B, "100B"},
    		{"KB", "1kb", KB, "1KB"},
    		{"KB", "100kb", 100 * KB, "100KB"},
    		{"MB", "1Mb", MB, "1MB"},
    		{"MB", "1000Mb", 1000 * MB, "1000MB"},
    		{"TB", "1Tb", TB, "1TB"},
    		{"PB", "1Pb", PB, "1PB"},
    		{"unknown", "1G", B, "1B"}, // 不能通过
    	}
    }

    // cd ./util
    // go test

    func TestMain(m *testing.M) {
    	initCommonData()
    	m.Run()
    }

    // 功能测试一般实现
    func TestParseSize(t *testing.T) {
    	t.Parallel()
    	testData := commTestData
    	for _, data := range testData {
    		size, sizeStr := ParseSize(data.SizeStr)
    		if size != data.ExpectSize || sizeStr != data.ExpectSizeStr {
    			t.Errorf("不符合预期：%+v\n", data)
    		}
    	}
    }

    // 功能测试，子测试
    // 仅测试一个组的子测试 go test -run TestParseSizeSub/PB
    func TestParseSizeSub(t *testing.T) {
    	t.Parallel() // 允许并行多个Test; go test -cpu 1,2 指定cpu1核执行一次，2核再执行一次，共2次
    	// go test -cpu 1,2 -count 3 一共执行6次
    	// go test -cpu 1,2 -count 3 -cover 打印测试用例共覆盖了多少代码
    	if testing.Short() { // go test -short 跳过了自测试用例
    		t.Skip("short mod 跳过该测试用例")
    	}
    	testdata := make(map[string][]commStruct, 0) // 数据分组
    	for _, item := range commTestData {
    		group := item.Group
    		_, ok := testdata[group]
    		if !ok {
    			testdata[group] = make([]commStruct, 0)
    		}
    		testdata[group] = append(testdata[group], item)
    	}
    	for k, item := range testdata {
    		t.Run(k, func(t1 *testing.T) {
    			for _, data := range item {
    				size, sizeStr := ParseSize(data.SizeStr)
    				if size != data.ExpectSize || sizeStr != data.ExpectSizeStr {
    					t1.Errorf("不符合预期：%+v\n", data)
    				}
    			}
    		})
    	}
    }

单元测试-模糊测试

  • util_test.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // go test -run ^$ -fuzz . -fuzztime 20s 运行20秒模糊测试，并不允许功能测试，因为功能测试不通过不会进行模糊测试
    // go test -run ^$ -fuzz . -fuzztime 20x 运行20次模糊测试
    // 当模糊测试未通过的时候，会自动生成一个语料库文件，此时再进行功能测试，也会重新进行该文件中记录的输入的测试
    func FuzzParseSize(f *testing.F) {
    	f.Fuzz(func(t *testing.T, a string) {
    		size, sizeStr := ParseSize(a)   // a是框架提供的随机值，我们也不知道是什么
    		if size == 0 && sizeStr == "" { // 暂时认为这是失败的
    			t.Error("输入异常导致ParseSize没有拿到正确的值")
    		}
    	})
    }

单元测试-基准（性能）测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// go test -run ^$ -bench . -benchtime 20x 运行20次性能测试
// go test -run ^$ -bench . -benchtime 20s 运行20秒性能测试
// go test -run ^$ -benchmem -bench . -benchtime 20x 同时打印每次的内存分配
func BenchmarkParseSize(b *testing.B) {
	for i := 0; i < b.N; i++ { // N是flag中给出的,如果没给出由框架给出
		ParseSize("100MB")
	}
}

// 性能测试分组子测试
func BenchmarkParseSizeSub(b *testing.B) {
	testdata := make(map[string][]commStruct, 0) // 数据分组
	for _, item := range commTestData {
		group := item.Group
		_, ok := testdata[group]
		if !ok {
			testdata[group] = make([]commStruct, 0)
		}
		testdata[group] = append(testdata[group], item)
	}
	b.ResetTimer() // 前面的分组操作不要算在测试时间里，但是这里是没有意义的，因为下面的子测试是单独的测试，使用的是b1不是b
	for k, item := range testdata {
		b.Run(k, func(b1 *testing.B) {
			for i := 0; i < b1.N; i++ {
				ParseSize(item[0].SizeStr)
			}
		})
	}
}

// 性能测试并行测试
// goroutine 默认为 GOMAXPROCS
// go test -run ^$ -benchmem -bench BenchmarkParseSizeParallel -benchtime 20x
func BenchmarkParseSizeParallel(b *testing.B) {
	b.RunParallel(func(p *testing.PB) {
		for p.Next() {
			ParseSize("10Gb")
		}
	})
}

单元测试-http测试

  • http.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    package httptest

    import (
    	"encoding/json"
    	"log"
    	"net/http"
    )

    func Web(addr string) {
    	http.HandleFunc("/hello", HelloHandler)
    	http.HandleFunc("/ping", PingHandler)
    	err := http.ListenAndServe(addr, nil)
    	if err != nil {
    		log.Fatal(err)
    	}
    }

    func HelloHandler(w http.ResponseWriter, req *http.Request) {
    	say := req.FormValue("say")
    	res := make(map[string]string, 0)
    	res["method"] = req.Method
    	res["say"] = say
    	w.WriteHeader(http.StatusOK)
    	bytes, _ := json.Marshal(res)
    	w.Write(bytes)
    }
    func PingHandler(w http.ResponseWriter, req *http.Request) {
    	w.WriteHeader(http.StatusOK)
    	res := make(map[string]string, 0)
    	res["msg"] = "pong"
    	bytes, _ := json.Marshal(res)
    	w.Write(bytes)
    }

  • http_test.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    package httptest

    import (
    	"encoding/json"
    	"io"
    	"net"
    	"net/http"
    	"net/http/httptest"
    	"net/url"
    	"strings"
    	"testing"
    )

    func handleError(tb testing.TB, err error) {
    	// 标识此函数是帮助函数，出错追踪的行号会忽略当前函数里面的内容，将行号打印为外部调用该函数的位置
    	tb.Helper()
    	if err != nil {
    		tb.Fatal(err)
    	}
    }

    // 1、 采用真实的http请求进行测试
    // go test ./httptest/
    func TestGetHello(t *testing.T) {
    	testData := map[string]string{
    		"method": "GET",
    		"say":    "hi",
    	}
    	ln, err := net.Listen("tcp", ":8899")   // 我们不能确定在测试的时候，服务是启动的，这里我们自己启动一个服务
    	http.HandleFunc("/hello", HelloHandler) // 再注册handler
    	go func() {
    		err := http.Serve(ln, nil)
    		handleError(t, err)
    	}()
    	v := url.Values{}
    	v.Set("say", testData["say"])
    	u := url.URL{
    		Scheme:   "http",
    		Host:     ln.Addr().String(),
    		Path:     "/hello",
    		RawQuery: v.Encode(),
    	}
    	resp, err := http.Get(u.String())
    	handleError(t, err)
    	defer resp.Body.Close()
    	body, err := io.ReadAll(resp.Body)
    	handleError(t, err)
    	mp := make(map[string]string)
    	err = json.Unmarshal(body, &mp)
    	handleError(t, err)
    	if mp["method"] != testData["method"] || mp["say"] != testData["say"] {
    		// 检查是否符合预期
    		t.Fatal("get 请求 hello接口没有获取到预期的结果")
    	}
    }

    // 2、 采用httptest模拟http请求过程（仅测试handler、更常用的方法、一般情况下这样测试接口就行）
    func TestPostHello(t *testing.T) {
    	testData := map[string]string{
    		"method": "POST",
    		"say":    "hi",
    	}
    	v := url.Values{}
    	v.Set("say", testData["say"])
    	payLoad := strings.NewReader(v.Encode())
    	req := httptest.NewRequest("POST", "http://mydomain:8899/hello", payLoad) // 虚拟地址，只需要格式正确即可，反正是模拟的
    	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    	w := httptest.NewRecorder()
    	HelloHandler(w, req)
    	body, err := io.ReadAll(w.Result().Body)
    	handleError(t, err)
    	mp := make(map[string]string)
    	err = json.Unmarshal(body, &mp)
    	handleError(t, err)
    	if mp["method"] != testData["method"] || mp["say"] != testData["say"] {
    		// 检查是否符合预期
    		t.Fatal("post 请求 hello接口没有获取到预期的结果")
    	}
    }

    // 性能测试
    //
    //	go test ./httptest/ -v -bench .
    func BenchmarkHelloHandler(b *testing.B) {
    	testData := map[string]string{
    		"method": "POST",
    		"say":    "hi",
    	}
    	b.ResetTimer() // 防止上面的内容影响测试时间
    	for i := 0; i < b.N; i++ {
    		v := url.Values{}
    		v.Set("say", testData["say"])
    		payLoad := strings.NewReader(v.Encode())
    		req := httptest.NewRequest("POST", "http://mydomain:8899/hello", payLoad) // 虚拟地址，只需要格式正确即可，反正是模拟的
    		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    		w := httptest.NewRecorder()
    		b.StartTimer()
    		HelloHandler(w, req) // 只有这一段是希望计算时间的内容，所以在前面开启时间，后面暂停时间
    		b.StopTimer()
    		body, err := io.ReadAll(w.Result().Body)
    		handleError(b, err)
    		mp := make(map[string]string)
    		err = json.Unmarshal(body, &mp)
    		handleError(b, err)
    		if mp["method"] != testData["method"] || mp["say"] != testData["say"] {
    			// 检查是否符合预期
    			b.Fatal("post 请求 hello接口没有获取到预期的结果")
    		}
    	}
    }

pprof性能分析工具

  • 性能分析调优方向
    1. cpu
    2. 内存
    3. 磁盘I/O
    4. 协程的阻塞
    5. 死锁的分析
  • pprof能做什么
    1. cpu使用情况分析
    2. 内存使用情况分析
    3. 阻塞block分析
    4. 互斥锁mutex的情况分析
  • 注意什么
    1. 生产环境下性能分析，选择流量较少的时间段
    2. 建议使用测试环境模拟生产环境进行性能分析
  • 数据采集方式与可采集数据
    1. web网页采集：cpu、内存、阻塞、协程、锁
    2. 通过基准（性能）测试导出数据文件：cpu、内存、阻塞、锁
    3. 通过硬编码获取数据：cpu、内存
  • 数据分析方式
    1. 命令行分析
    2. web网页做分析

数据采集

  • 测试接口
    1
    2
    3
    4
    5
    6
    package data

    type Cmd interface {
    	Name() string
    	Run()
    }
  • 定义常量
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package constants

    const (
    	I = 1 << (iota * 10)
    	Ki
    	Mi
    	Gi
    	Ti
    	Pi
    )
  • 异常测试案例
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    package block

    import (
    	"log"
    	"time"
    )

    type Block struct {
    }

    func (b *Block) Name() string {
    	return "block"
    }

    func (b *Block) Run() {
    	log.Println(b.Name(), "Run")
    	<-time.After(time.Second)
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package cpu

    import (
    	"log"
    )

    type Cpu struct {
    }

    func (c *Cpu) Name() string {
    	return "cpu"
    }

    func (c *Cpu) Run() {
    	log.Println(c.Name(), "Run")
    	for i := 0; i < 1000000000; i++ {

    	}
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package goroutine

    import (
    	"log"
    	"time"
    )

    type Goroutine struct{}

    func (g *Goroutine) Name() string {
    	return "goroutine"
    }

    func (g *Goroutine) Run() {
    	log.Println(g.Name(), "Run")
    	for i := 0; i < 10; i++ {
    		go func() {
    			time.Sleep(30 * time.Second)
    		}()
    	}
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    package mem

    import (
    	"log"
    	"test-case/pprof/constants"
    )

    type Mem struct {
    	buffer [][constants.Ki]byte
    }

    func (m *Mem) Name() string {
    	return "mem"
    }

    func (m *Mem) Run() {
    	log.Println(m.Name(), "Run")
    	max := constants.Mi
    	for len(m.buffer)*constants.Ki < max {
    		m.buffer = append(m.buffer, [constants.Ki]byte{})
    	}
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    package mutex

    import (
    	"log"
    	"sync"
    	"time"
    )

    type Mutex struct{}

    func (m *Mutex) Name() string {
    	return "mutex"
    }

    func (m *Mutex) Run() {
    	log.Println(m.Name(), "Run")
    	mutex := &sync.Mutex{}
    	mutex.Lock()
    	go func() {
    		time.Sleep(time.Second)
    		mutex.Unlock()
    	}()
    	mutex.Lock()
    }

web数据采集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package main

import (
	"log"
	"net/http"
	_ "net/http/pprof" // 需要手动引用
	"os"
	"runtime"
	"test-case/pprof/data"
	"test-case/pprof/data/block"
	"test-case/pprof/data/cpu"
	"test-case/pprof/data/goroutine"
	"test-case/pprof/data/mem"
	"test-case/pprof/data/mutex"
	"time"
)

var cmds = []data.Cmd{
	&cpu.Cpu{},
	&mem.Mem{},
	&block.Block{},
	&goroutine.Goroutine{},
	&mutex.Mutex{},
}

func main() {
	// 开启对阻塞操作的跟踪
	runtime.SetBlockProfileRate(1)
	// 开启对锁调用的跟踪
	runtime.SetMutexProfileFraction(1)
	// 网页采集数据
	// go run .
	// 访问 127.0.0.1:6060/debug/pprof
	// 可以选择对应指标进行文件下载
	go func() {
		if err := http.ListenAndServe(":6060", nil); err != nil {
			log.Fatal(err)
		}
		os.Exit(1)
	}()
	for {
		for _, v := range cmds {
			v.Run()
		}
		time.Sleep(time.Second)
	}
}

基准测试数据采集

  • data_test.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    package datatest_test

    import (
    	"test-case/pprof/data/cpu"
    	"test-case/pprof/data/mem"
    	"testing"
    )

    // go test -run ^$ -bench . ./data_test/ -cpuprofile cpu.out -memprofile mem.out -outputdir ./testout/
    func BenchmarkData(b *testing.B) {
    	b.Run("cpu", func(b1 *testing.B) {
    		o := cpu.Cpu{}
    		for i := 0; i < b1.N; i++ {
    			o.Run()
    		}
    	})
    	b.Run("mem", func(b1 *testing.B) {
    		o := mem.Mem{}
    		for i := 0; i < b1.N; i++ {
    			o.Run()
    		}
    	})
    }

硬编码数据采集

  • main.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    package main

    import (
    	"log"
    	"os"
    	"runtime/pprof" // 注意这里不是http的pprof包，是runtime的
    	"test-case/pprof/data"
    	"test-case/pprof/data/block"
    	"test-case/pprof/data/cpu"
    	"test-case/pprof/data/goroutine"
    	"test-case/pprof/data/mem"
    	"test-case/pprof/data/mutex"
    )

    var cmds = []data.Cmd{
    	&cpu.Cpu{},
    	&mem.Mem{},
    	&block.Block{},
    	&goroutine.Goroutine{},
    	&mutex.Mutex{},
    }

    func main() {
    	cpufile, err := os.OpenFile("./out/cpu.out", os.O_CREATE|os.O_WRONLY, 0644)
    	if err != nil {
    		log.Fatal(err)
    	}
    	err = pprof.StartCPUProfile(cpufile)
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer pprof.StopCPUProfile()

    	memfile, err := os.OpenFile("./out/mem.out", os.O_CREATE|os.O_WRONLY, 0644)
    	if err != nil {
    		log.Fatal(err)
    	}
    	pprof.WriteHeapProfile(memfile)

    	for i := 0; i < 20; i++ {
    		for _, v := range cmds {
    			v.Run()
    		}
    	}
    }

数据分析

命令行分析

对本地profile文件进行分析

alt text

  • 指标
    1. Flat 函数自身运行所消耗的资源
    2. Flat% 函数自身资源消耗比例
    3. Sum% 当前行的flag% 与上面所有行的flat%的总和
    4. Cum 当前函数加上其调用栈的运行总消耗
    5. Cum% 当前函数加上其调用栈的运行总消耗百分比
  • 最常用的性能分析命令
    1. top列出资源消耗最多的方法
    2. list 输出匹配regexp 带注释的源码
    3. web 生成图片，默认使用浏览器打开（需要安装插件）
对pprof网页结果进行分析

alt text

  • 生成web结果图片
    alt text
    alt text

Web分析

  • 安装插件
    • graphviz.gitlab.io/download/
  • 启动web分析服务
    alt text
    alt text
  • 找最粗的线，就是性能有问题的地方
2024-12-05 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go语言】Golang数据结构与算法 下一篇：【go语言】Golang网络编程
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题