主頁 > 後端開發 > Go語言基礎之單元測驗

Go語言基礎之單元測驗

2020-09-15 05:52:07 後端開發

不寫測驗的開發不是好程式員，我個人非常崇尚TDD（Test Driven Development）的，然而可惜的是國內的程式員都不太關注測驗這一部分， 這篇文章主要介紹下在Go語言中如何做單元測驗和基準測驗，

go test工具

Go語言中的測驗依賴go test命令，撰寫測驗代碼和撰寫普通的Go代碼程序是類似的，并不需要學習新的語法、規則或工具，

go test命令是一個按照一定約定和組織的測驗代碼的驅動程式，在包目錄內，所有以_test.go為后綴名的源代碼檔案都是go test測驗的一部分，不會被go build編譯到最終的可執行檔案中，

在*_test.go檔案中有三種型別的函式，單元測驗函式、基準測驗函式和示例函式，

型別格式作用
測驗函式 函式名前綴為Test 測驗程式的一些邏輯行為是否正確
基準函式 函式名前綴為Benchmark 測驗函式的性能
示例函式 函式名前綴為Example 為檔案提供示例檔案

go test命令會遍歷所有的*_test.go檔案中符合上述命名規則的函式，然后生成一個臨時的main包用于呼叫相應的測驗函式，然后構建并運行、報告測驗結果，最后清理測驗中生成的臨時檔案，

測驗函式

測驗函式的格式

每個測驗函式必須匯入testing包，測驗函式的基本格式（簽名）如下：

func TestName(t *testing.T){
    // ...
}

測驗函式的名字必須以Test開頭，可選的后綴名必須以大寫字母開頭，舉幾個例子：

func TestAdd(t *testing.T){ ... }
func TestSum(t *testing.T){ ... }
func TestLog(t *testing.T){ ... }

其中引數t用于報告測驗失敗和附加的日志資訊， testing.T的擁有的方法如下：

func (c *T) Error(args ...interface{})
func (c *T) Errorf(format string, args ...interface{})
func (c *T) Fail()
func (c *T) FailNow()
func (c *T) Failed() bool
func (c *T) Fatal(args ...interface{})
func (c *T) Fatalf(format string, args ...interface{})
func (c *T) Log(args ...interface{})
func (c *T) Logf(format string, args ...interface{})
func (c *T) Name() string
func (t *T) Parallel()
func (t *T) Run(name string, f func(t *T)) bool
func (c *T) Skip(args ...interface{})
func (c *T) SkipNow()
func (c *T) Skipf(format string, args ...interface{})
func (c *T) Skipped() bool

測驗函式示例

就像細胞是構成我們身體的基本單位，一個軟體程式也是由很多單元組件構成的，單元組件可以是函式、結構體、方法和最終用戶可能依賴的任意東西，總之我們需要確保這些組件是能夠正常運行的，單元測驗是一些利用各種方法測驗單元組件的程式，它會將結果與預期輸出進行比較，

接下來，我們定義一個split的包，包中定義了一個Split函式，具體實作如下：

// split/split.go

package split

import "strings"

// split package with a single split function.

// Split slices s into all substrings separated by sep and
// returns a slice of the substrings between those separators.
func Split(s, sep string) (result []string) {
	i := strings.Index(s, sep)

	for i > -1 {
		result = append(result, s[:i])
		s = s[i+1:]
		i = strings.Index(s, sep)
	}
	result = append(result, s)
	return
}

在當前目錄下，我們創建一個split_test.go的測驗檔案，并定義一個測驗函式如下：

// split/split_test.go

package split

import (
	"reflect"
	"testing"
)

func TestSplit(t *testing.T) { // 測驗函式名必須以Test開頭，必須接收一個*testing.T型別引數
	got := Split("a:b:c", ":")         // 程式輸出的結果
	want := []string{"a", "b", "c"}    // 期望的結果
	if !reflect.DeepEqual(want, got) { // 因為slice不能比較直接，借助反射包中的方法比較
		t.Errorf("excepted:%v, got:%v", want, got) // 測驗失敗輸出錯誤提示
	}
}

此時split這個包中的檔案如下：

split $ ls -l
total 16
-rw-r--r--  1 liwenzhou  staff  408  4 29 15:50 split.go
-rw-r--r--  1 liwenzhou  staff  466  4 29 16:04 split_test.go

在split包路徑下，執行go test命令，可以看到輸出結果如下：

split $ go test
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       0.005s

一個測驗用例有點單薄，我們再撰寫一個測驗使用多個字符切割字串的例子，在split_test.go中添加如下測驗函式：

func TestMoreSplit(t *testing.T) {
	got := Split("abcd", "bc")
	want := []string{"a", "d"}
	if !reflect.DeepEqual(want, got) {
		t.Errorf("excepted:%v, got:%v", want, got)
	}
}

再次運行go test命令，輸出結果如下：

split $ go test
--- FAIL: TestMultiSplit (0.00s)
    split_test.go:20: excepted:[a d], got:[a cd]
FAIL
exit status 1
FAIL    github.com/Q1mi/studygo/code_demo/test_demo/split       0.006s

這一次，我們的測驗失敗了，我們可以為go test命令添加-v引數，查看測驗函式名稱和運行時間：

split $ go test -v
=== RUN   TestSplit
--- PASS: TestSplit (0.00s)
=== RUN   TestMoreSplit
--- FAIL: TestMoreSplit (0.00s)
    split_test.go:21: excepted:[a d], got:[a cd]
FAIL
exit status 1
FAIL    github.com/Q1mi/studygo/code_demo/test_demo/split       0.005s

這一次我們能清楚的看到是TestMoreSplit這個測驗沒有成功， 還可以在go test命令后添加-run引數，它對應一個正則運算式，只有函式名匹配上的測驗函式才會被go test命令執行，

split $ go test -v -run="More"
=== RUN   TestMoreSplit
--- FAIL: TestMoreSplit (0.00s)
    split_test.go:21: excepted:[a d], got:[a cd]
FAIL
exit status 1
FAIL    github.com/Q1mi/studygo/code_demo/test_demo/split       0.006s

現在我們回過頭來解決我們程式中的問題，很顯然我們最初的split函式并沒有考慮到sep為多個字符的情況，我們來修復下這個Bug：

package split

import "strings"

// split package with a single split function.

// Split slices s into all substrings separated by sep and
// returns a slice of the substrings between those separators.
func Split(s, sep string) (result []string) {
	i := strings.Index(s, sep)

	for i > -1 {
		result = append(result, s[:i])
		s = s[i+len(sep):] // 這里使用len(sep)獲取sep的長度
		i = strings.Index(s, sep)
	}
	result = append(result, s)
	return
}

這一次我們再來測驗一下，我們的程式，注意，當我們修改了我們的代碼之后不要僅僅執行那些失敗的測驗函式，我們應該完整的運行所有的測驗，保證不會因為修改代碼而引入了新的問題，

split $ go test -v
=== RUN   TestSplit
--- PASS: TestSplit (0.00s)
=== RUN   TestMoreSplit
--- PASS: TestMoreSplit (0.00s)
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       0.006s

這一次我們的測驗都通過了，

測驗組

我們現在還想要測驗一下split函式對中文字串的支持，這個時候我們可以再撰寫一個TestChineseSplit測驗函式，但是我們也可以使用如下更友好的一種方式來添加更多的測驗用例，

func TestSplit(t *testing.T) {
   // 定義一個測驗用例型別
	type test struct {
		input string
		sep   string
		want  []string
	}
	// 定義一個存盤測驗用例的切片
	tests := []test{
		{input: "a:b:c", sep: ":", want: []string{"a", "b", "c"}},
		{input: "a:b:c", sep: ",", want: []string{"a:b:c"}},
		{input: "abcd", sep: "bc", want: []string{"a", "d"}},
		{input: "沙河有沙又有河", sep: "沙", want: []string{"河有", "又有河"}},
	}
	// 遍歷切片，逐一執行測驗用例
	for _, tc := range tests {
		got := Split(tc.input, tc.sep)
		if !reflect.DeepEqual(got, tc.want) {
			t.Errorf("excepted:%v, got:%v", tc.want, got)
		}
	}
}

我們通過上面的代碼把多個測驗用例合到一起，再次執行go test命令，

split $ go test -v
=== RUN   TestSplit
--- FAIL: TestSplit (0.00s)
    split_test.go:42: excepted:[河有 又有河], got:[ 河有 又有河]
FAIL
exit status 1
FAIL    github.com/Q1mi/studygo/code_demo/test_demo/split       0.006s

我們的測驗出現了問題，仔細看列印的測驗失敗提示資訊：excepted:[河有 又有河], got:[ 河有 又有河]，你會發現[ 河有 又有河]中有個不明顯的空串，這種情況下十分推薦使用%#v的格式化方式，

我們修改下測驗用例的格式化輸出錯誤提示部分：

func TestSplit(t *testing.T) {
   ...
   
	for _, tc := range tests {
		got := Split(tc.input, tc.sep)
		if !reflect.DeepEqual(got, tc.want) {
			t.Errorf("excepted:%#v, got:%#v", tc.want, got)
		}
	}
}

此時運行go test命令后就能看到比較明顯的提示資訊了：

split $ go test -v
=== RUN   TestSplit
--- FAIL: TestSplit (0.00s)
    split_test.go:42: excepted:[]string{"河有", "又有河"}, got:[]string{"", "河有", "又有河"}
FAIL
exit status 1
FAIL    github.com/Q1mi/studygo/code_demo/test_demo/split       0.006s

子測驗

看起來都挺不錯的，但是如果測驗用例比較多的時候，我們是沒辦法一眼看出來具體是哪個測驗用例失敗了，我們可能會想到下面的解決辦法：

func TestSplit(t *testing.T) {
	type test struct { // 定義test結構體
		input string
		sep   string
		want  []string
	}
	tests := map[string]test{ // 測驗用例使用map存盤
		"simple":      {input: "a:b:c", sep: ":", want: []string{"a", "b", "c"}},
		"wrong sep":   {input: "a:b:c", sep: ",", want: []string{"a:b:c"}},
		"more sep":    {input: "abcd", sep: "bc", want: []string{"a", "d"}},
		"leading sep": {input: "沙河有沙又有河", sep: "沙", want: []string{"河有", "又有河"}},
	}
	for name, tc := range tests {
		got := Split(tc.input, tc.sep)
		if !reflect.DeepEqual(got, tc.want) {
			t.Errorf("name:%s excepted:%#v, got:%#v", name, tc.want, got) // 將測驗用例的name格式化輸出
		}
	}
}

上面的做法是能夠解決問題的，同時Go1.7+中新增了子測驗，我們可以按照如下方式使用t.Run執行子測驗：

func TestSplit(t *testing.T) {
	type test struct { // 定義test結構體
		input string
		sep   string
		want  []string
	}
	tests := map[string]test{ // 測驗用例使用map存盤
		"simple":      {input: "a:b:c", sep: ":", want: []string{"a", "b", "c"}},
		"wrong sep":   {input: "a:b:c", sep: ",", want: []string{"a:b:c"}},
		"more sep":    {input: "abcd", sep: "bc", want: []string{"a", "d"}},
		"leading sep": {input: "沙河有沙又有河", sep: "沙", want: []string{"河有", "又有河"}},
	}
	for name, tc := range tests {
		t.Run(name, func(t *testing.T) { // 使用t.Run()執行子測驗
			got := Split(tc.input, tc.sep)
			if !reflect.DeepEqual(got, tc.want) {
				t.Errorf("excepted:%#v, got:%#v", tc.want, got)
			}
		})
	}
}

此時我們再執行go test命令就能夠看到更清晰的輸出內容了：

split $ go test -v
=== RUN   TestSplit
=== RUN   TestSplit/leading_sep
=== RUN   TestSplit/simple
=== RUN   TestSplit/wrong_sep
=== RUN   TestSplit/more_sep
--- FAIL: TestSplit (0.00s)
    --- FAIL: TestSplit/leading_sep (0.00s)
        split_test.go:83: excepted:[]string{"河有", "又有河"}, got:[]string{"", "河有", "又有河"}
    --- PASS: TestSplit/simple (0.00s)
    --- PASS: TestSplit/wrong_sep (0.00s)
    --- PASS: TestSplit/more_sep (0.00s)
FAIL
exit status 1
FAIL    github.com/Q1mi/studygo/code_demo/test_demo/split       0.006s

這個時候我們要把測驗用例中的錯誤修改回來：

func TestSplit(t *testing.T) {
	...
	tests := map[string]test{ // 測驗用例使用map存盤
		"simple":      {input: "a:b:c", sep: ":", want: []string{"a", "b", "c"}},
		"wrong sep":   {input: "a:b:c", sep: ",", want: []string{"a:b:c"}},
		"more sep":    {input: "abcd", sep: "bc", want: []string{"a", "d"}},
		"leading sep": {input: "沙河有沙又有河", sep: "沙", want: []string{"", "河有", "又有河"}},
	}
	...
}

我們都知道可以通過-run=RegExp來指定運行的測驗用例，還可以通過/來指定要運行的子測驗用例，例如：go test -v -run=Split/simple只會運行simple對應的子測驗用例，

測驗覆寫率

測驗覆寫率是你的代碼被測驗套件覆寫的百分比，通常我們使用的都是陳述句的覆寫率，也就是在測驗中至少被運行一次的代碼占總代碼的比例，

Go提供內置功能來檢查你的代碼覆寫率，我們可以使用go test -cover來查看測驗覆寫率，例如：

split $ go test -cover
PASS
coverage: 100.0% of statements
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       0.005s

從上面的結果可以看到我們的測驗用例覆寫了100%的代碼，

Go還提供了一個額外的-coverprofile引數，用來將覆寫率相關的記錄資訊輸出到一個檔案，例如：

split $ go test -cover -coverprofile=c.out
PASS
coverage: 100.0% of statements
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       0.005s

上面的命令會將覆寫率相關的資訊輸出到當前檔案夾下面的c.out檔案中，然后我們執行go tool cover -html=c.out，使用cover工具來處理生成的記錄資訊，該命令會打開本地的瀏覽器視窗生成一個HTML報告， 

上圖中每個用綠色標記的陳述句塊表示被覆寫了，而紅色的表示沒有被覆寫，

基準測驗

基準測驗函式格式

基準測驗就是在一定的作業負載之下檢測程式性能的一種方法，基準測驗的基本格式如下：

func BenchmarkName(b *testing.B){
    // ...
}

基準測驗以Benchmark為前綴，需要一個*testing.B型別的引數b，基準測驗必須要執行b.N次，這樣的測驗才有對照性，b.N的值是系統根據實際情況去調整的，從而保證測驗的穩定性， testing.B擁有的方法如下：

func (c *B) Error(args ...interface{})
func (c *B) Errorf(format string, args ...interface{})
func (c *B) Fail()
func (c *B) FailNow()
func (c *B) Failed() bool
func (c *B) Fatal(args ...interface{})
func (c *B) Fatalf(format string, args ...interface{})
func (c *B) Log(args ...interface{})
func (c *B) Logf(format string, args ...interface{})
func (c *B) Name() string
func (b *B) ReportAllocs()
func (b *B) ResetTimer()
func (b *B) Run(name string, f func(b *B)) bool
func (b *B) RunParallel(body func(*PB))
func (b *B) SetBytes(n int64)
func (b *B) SetParallelism(p int)
func (c *B) Skip(args ...interface{})
func (c *B) SkipNow()
func (c *B) Skipf(format string, args ...interface{})
func (c *B) Skipped() bool
func (b *B) StartTimer()
func (b *B) StopTimer()

基準測驗示例

我們為split包中的Split函式撰寫基準測驗如下：

func BenchmarkSplit(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Split("沙河有沙又有河", "沙")
	}
}

基準測驗并不會默認執行，需要增加-bench引數，所以我們通過執行go test -bench=Split命令執行基準測驗，輸出結果如下：

split $ go test -bench=Split
goos: darwin
goarch: amd64
pkg: github.com/Q1mi/studygo/code_demo/test_demo/split
BenchmarkSplit-8        10000000               203 ns/op
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       2.255s

其中BenchmarkSplit-8表示對Split函式進行基準測驗，數字8表示GOMAXPROCS的值，這個對于并發基準測驗很重要，10000000和203ns/op表示每次呼叫Split函式耗時203ns，這個結果是10000000次呼叫的平均值，

我們還可以為基準測驗添加-benchmem引數，來獲得記憶體分配的統計資料，

split $ go test -bench=Split -benchmem
goos: darwin
goarch: amd64
pkg: github.com/Q1mi/studygo/code_demo/test_demo/split
BenchmarkSplit-8        10000000               215 ns/op             112 B/op          3 allocs/op
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       2.394s

其中，112 B/op表示每次操作記憶體分配了112位元組，3 allocs/op則表示每次操作進行了3次記憶體分配， 我們將我們的Split函式優化如下：

func Split(s, sep string) (result []string) {
	result = make([]string, 0, strings.Count(s, sep)+1)
	i := strings.Index(s, sep)
	for i > -1 {
		result = append(result, s[:i])
		s = s[i+len(sep):] // 這里使用len(sep)獲取sep的長度
		i = strings.Index(s, sep)
	}
	result = append(result, s)
	return
}

這一次我們提前使用make函式將result初始化為一個容量足夠大的切片，而不再像之前一樣通過呼叫append函式來追加，我們來看一下這個改進會帶來多大的性能提升：

split $ go test -bench=Split -benchmem
goos: darwin
goarch: amd64
pkg: github.com/Q1mi/studygo/code_demo/test_demo/split
BenchmarkSplit-8        10000000               127 ns/op              48 B/op          1 allocs/op
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       1.423s

這個使用make函式提前分配記憶體的改動，減少了2/3的記憶體分配次數，并且減少了一半的記憶體分配，

性能比較函式

上面的基準測驗只能得到給定操作的絕對耗時，但是在很多性能問題是發生在兩個不同操作之間的相對耗時，比如同一個函式處理1000個元素的耗時與處理1萬甚至100萬個元素的耗時的差別是多少？再或者對于同一個任務究竟使用哪種演算法性能最佳？我們通常需要對兩個不同演算法的實作使用相同的輸入來進行基準比較測驗，

性能比較函式通常是一個帶有引數的函式，被多個不同的Benchmark函式傳入不同的值來呼叫，舉個例子如下：

func benchmark(b *testing.B, size int){/* ... */}
func Benchmark10(b *testing.B){ benchmark(b, 10) }
func Benchmark100(b *testing.B){ benchmark(b, 100) }
func Benchmark1000(b *testing.B){ benchmark(b, 1000) }

例如我們撰寫了一個計算斐波那契數列的函式如下：

// fib.go

// Fib 是一個計算第n個斐波那契數的函式
func Fib(n int) int {
	if n < 2 {
		return n
	}
	return Fib(n-1) + Fib(n-2)
}

我們撰寫的性能比較函式如下：

// fib_test.go

func benchmarkFib(b *testing.B, n int) {
	for i := 0; i < b.N; i++ {
		Fib(n)
	}
}

func BenchmarkFib1(b *testing.B)  { benchmarkFib(b, 1) }
func BenchmarkFib2(b *testing.B)  { benchmarkFib(b, 2) }
func BenchmarkFib3(b *testing.B)  { benchmarkFib(b, 3) }
func BenchmarkFib10(b *testing.B) { benchmarkFib(b, 10) }
func BenchmarkFib20(b *testing.B) { benchmarkFib(b, 20) }
func BenchmarkFib40(b *testing.B) { benchmarkFib(b, 40) }

運行基準測驗：

split $ go test -bench=.
goos: darwin
goarch: amd64
pkg: github.com/Q1mi/studygo/code_demo/test_demo/fib
BenchmarkFib1-8         1000000000               2.03 ns/op
BenchmarkFib2-8         300000000                5.39 ns/op
BenchmarkFib3-8         200000000                9.71 ns/op
BenchmarkFib10-8         5000000               325 ns/op
BenchmarkFib20-8           30000             42460 ns/op
BenchmarkFib40-8               2         638524980 ns/op
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/fib 12.944s

這里需要注意的是，默認情況下，每個基準測驗至少運行1秒，如果在Benchmark函式回傳時沒有到1秒，則b.N的值會按1,2,5,10,20,50，…增加，并且函式再次運行，

最終的BenchmarkFib40只運行了兩次，每次運行的平均值只有不到一秒，像這種情況下我們應該可以使用-benchtime標志增加最小基準時間，以產生更準確的結果，例如：

split $ go test -bench=Fib40 -benchtime=20s
goos: darwin
goarch: amd64
pkg: github.com/Q1mi/studygo/code_demo/test_demo/fib
BenchmarkFib40-8              50         663205114 ns/op
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/fib 33.849s

這一次BenchmarkFib40函式運行了50次，結果就會更準確一些了，

使用性能比較函式做測驗的時候一個容易犯的錯誤就是把b.N作為輸入的大小，例如以下兩個例子都是錯誤的示范：

// 錯誤示范1
func BenchmarkFibWrong(b *testing.B) {
	for n := 0; n < b.N; n++ {
		Fib(n)
	}
}

// 錯誤示范2
func BenchmarkFibWrong2(b *testing.B) {
	Fib(b.N)
}

重置時間

b.ResetTimer之前的處理不會放到執行時間里，也不會輸出到報告中，所以可以在之前做一些不計劃作為測驗報告的操作，例如：

func BenchmarkSplit(b *testing.B) {
	time.Sleep(5 * time.Second) // 假設需要做一些耗時的無關操作
	b.ResetTimer()              // 重置計時器
	for i := 0; i < b.N; i++ {
		Split("沙河有沙又有河", "沙")
	}
}

并行測驗

func (b *B) RunParallel(body func(*PB))會以并行的方式執行給定的基準測驗，

RunParallel會創建出多個goroutine，并將b.N分配給這些goroutine執行， 其中goroutine數量的默認值為GOMAXPROCS，用戶如果想要增加非CPU受限（non-CPU-bound）基準測驗的并行性， 那么可以在RunParallel之前呼叫SetParallelism ，RunParallel通常會與-cpu標志一同使用，

func BenchmarkSplitParallel(b *testing.B) {
	// b.SetParallelism(1) // 設定使用的CPU數
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			Split("沙河有沙又有河", "沙")
		}
	})
}

執行一下基準測驗：

split $ go test -bench=.
goos: darwin
goarch: amd64
pkg: github.com/Q1mi/studygo/code_demo/test_demo/split
BenchmarkSplit-8                10000000               131 ns/op
BenchmarkSplitParallel-8        50000000                36.1 ns/op
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       3.308s

還可以通過在測驗命令后添加-cpu引數如go test -bench=. -cpu 1來指定使用的CPU數量，

Setup與TearDown

測驗程式有時需要在測驗之前進行額外的設定（setup）或在測驗之后進行拆卸（teardown），

TestMain

通過在*_test.go檔案中定義TestMain函式來可以在測驗之前進行額外的設定（setup）或在測驗之后進行拆卸（teardown）操作，

如果測驗檔案包含函式:func TestMain(m *testing.M)那么生成的測驗會先呼叫 TestMain(m)，然后再運行具體測驗，TestMain運行在主goroutine中, 可以在呼叫 m.Run前后做任何設定（setup）和拆卸（teardown），退出測驗的時候應該使用m.Run的回傳值作為引數呼叫os.Exit，

一個使用TestMain來設定Setup和TearDown的示例如下：

func TestMain(m *testing.M) {
	fmt.Println("write setup code here...") // 測驗之前的做一些設定
	// 如果 TestMain 使用了 flags，這里應該加上flag.Parse()
	retCode := m.Run()                         // 執行測驗
	fmt.Println("write teardown code here...") // 測驗之后做一些拆卸作業
	os.Exit(retCode)                           // 退出測驗
}

需要注意的是：在呼叫TestMain時, flag.Parse并沒有被呼叫，所以如果TestMain 依賴于command-line標志 (包括 testing 包的標記), 則應該顯示的呼叫flag.Parse，

子測驗的Setup與Teardown

有時候我們可能需要為每個測驗集設定Setup與Teardown，也有可能需要為每個子測驗設定Setup與Teardown，下面我們定義兩個函式工具函式如下：

// 測驗集的Setup與Teardown
func setupTestCase(t *testing.T) func(t *testing.T) {
	t.Log("如有需要在此執行:測驗之前的setup")
	return func(t *testing.T) {
		t.Log("如有需要在此執行:測驗之后的teardown")
	}
}

// 子測驗的Setup與Teardown
func setupSubTest(t *testing.T) func(t *testing.T) {
	t.Log("如有需要在此執行:子測驗之前的setup")
	return func(t *testing.T) {
		t.Log("如有需要在此執行:子測驗之后的teardown")
	}
}

使用方式如下：

func TestSplit(t *testing.T) {
	type test struct { // 定義test結構體
		input string
		sep   string
		want  []string
	}
	tests := map[string]test{ // 測驗用例使用map存盤
		"simple":      {input: "a:b:c", sep: ":", want: []string{"a", "b", "c"}},
		"wrong sep":   {input: "a:b:c", sep: ",", want: []string{"a:b:c"}},
		"more sep":    {input: "abcd", sep: "bc", want: []string{"a", "d"}},
		"leading sep": {input: "沙河有沙又有河", sep: "沙", want: []string{"", "河有", "又有河"}},
	}
	teardownTestCase := setupTestCase(t) // 測驗之前執行setup操作
	defer teardownTestCase(t)            // 測驗之后執行testdoen操作

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) { // 使用t.Run()執行子測驗
			teardownSubTest := setupSubTest(t) // 子測驗之前執行setup操作
			defer teardownSubTest(t)           // 測驗之后執行testdoen操作
			got := Split(tc.input, tc.sep)
			if !reflect.DeepEqual(got, tc.want) {
				t.Errorf("excepted:%#v, got:%#v", tc.want, got)
			}
		})
	}
}

測驗結果如下：

split $ go test -v
=== RUN   TestSplit
=== RUN   TestSplit/simple
=== RUN   TestSplit/wrong_sep
=== RUN   TestSplit/more_sep
=== RUN   TestSplit/leading_sep
--- PASS: TestSplit (0.00s)
    split_test.go:71: 如有需要在此執行:測驗之前的setup
    --- PASS: TestSplit/simple (0.00s)
        split_test.go:79: 如有需要在此執行:子測驗之前的setup
        split_test.go:81: 如有需要在此執行:子測驗之后的teardown
    --- PASS: TestSplit/wrong_sep (0.00s)
        split_test.go:79: 如有需要在此執行:子測驗之前的setup
        split_test.go:81: 如有需要在此執行:子測驗之后的teardown
    --- PASS: TestSplit/more_sep (0.00s)
        split_test.go:79: 如有需要在此執行:子測驗之前的setup
        split_test.go:81: 如有需要在此執行:子測驗之后的teardown
    --- PASS: TestSplit/leading_sep (0.00s)
        split_test.go:79: 如有需要在此執行:子測驗之前的setup
        split_test.go:81: 如有需要在此執行:子測驗之后的teardown
    split_test.go:73: 如有需要在此執行:測驗之后的teardown
=== RUN   ExampleSplit
--- PASS: ExampleSplit (0.00s)
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       0.006s

示例函式

示例函式的格式

被go test特殊對待的第三種函式就是示例函式，它們的函式名以Example為前綴，它們既沒有引數也沒有回傳值，標準格式如下：

func ExampleName() {
    // ...
}

示例函式示例

下面的代碼是我們為Split函式撰寫的一個示例函式：

func ExampleSplit() {
	fmt.Println(split.Split("a:b:c", ":"))
	fmt.Println(split.Split("沙河有沙又有河", "沙"))
	// Output:
	// [a b c]
	// [ 河有 又有河]
}

為你的代碼撰寫示例代碼有如下三個用處：

  1. 示例函式能夠作為檔案直接使用，例如基于web的godoc中能把示例函式與對應的函式或包相關聯，

  2. 示例函式只要包含了// Output:也是可以通過go test運行的可執行測驗，

    split $ go test -run Example
PASS
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       0.006s

  1. 示例函式提供了可以直接運行的示例代碼，可以直接在golang.org的godoc檔案服務器上使用Go Playground運行示例代碼，下圖為strings.ToUpper函式在Playground的示例函式效果， 

練習題

  1. 撰寫一個回文檢測函式，并為其撰寫單元測驗和基準測驗，根據測驗的結果逐步對其進行優化，（回文：一個字串正序和逆序一樣，如“Madam,I’mAdam”、“油燈少燈油”等，）

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/43070.html

標籤：Go

上一篇：Go語言學習筆記（二）

下一篇：Go語言基礎之網路編程

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂