惠城网站设计,公益广告设计图片,c 转网站开发,长春网站排名方案go的两大测试方法- 官网推荐 go的两大测试方法- 官网推荐常见的不正规测试方法main方法个例测试验证 - 不正规1. 提供一个函数#xff1a;Reverse(input string)进行测试2. 直接在函数下创建main函数下进行个例测试3. 测试发现#xff0c;Reverse方法不支持某些汉字#xff… go的两大测试方法- 官网推荐 go的两大测试方法- 官网推荐常见的不正规测试方法main方法个例测试验证 - 不正规1. 提供一个函数Reverse(input string)进行测试2. 直接在函数下创建main函数下进行个例测试3. 测试发现Reverse方法不支持某些汉字因为汉字不是单字节所以使用rune来装字符所以增加了多一个方法Reverse14. 再次在main中测试5. 经过测试后个例反转的效果是正确。但是个例毕竟还是个例。官网里面存在测试的使用教程。下面继续吧。 go官方推荐测试方式一单元unit 测试1. 新建一个go文件要求文件命名为 待测试文件名 _test.go2. 进行测试验证3. unit单元测试局限性4. unit单元测试的优点 fuzz模糊测试1. 在fuzzingToLearn_test文件中添加模糊测试的代码 - 两个方法测试2. 终端运行测试1. 使用终端先使用run test验证是否通过2. 使用fuzz模糊测试验证查看任何随机生成的字符串输入是否会导致失败3. 使用fuzz模糊测试FuzzReverse1方法代码改动4. 使用fuzz验证诊断代码 end所有的代码 go的两大测试方法- 官网推荐
常见的不正规测试方法
main方法个例测试验证 - 不正规
1. 提供一个函数Reverse(input string)进行测试
2. 直接在函数下创建main函数下进行个例测试
package mainimport (fmt
)// Reverse 字节 反转字符串
func Reverse(input string) string {bytes : []byte(input)for i, j : 0, len(bytes)-1; i len(bytes)/2; i, j i1, j-1 {bytes[i], bytes[j] bytes[j], bytes[i]}return string(bytes)
}func main() {input : hello, world , java页, go bigdatafirstRev : Reverse(input)secondRev : Reverse(firstRev)fmt.Printf(原始数据: %q\n, input)fmt.Printf(第一次反转的数据: %q\n, firstRev)fmt.Printf(反转数据再次反转的数据: %q\n, secondRev)
}
3. 测试发现Reverse方法不支持某些汉字因为汉字不是单字节所以使用rune来装字符所以增加了多一个方法Reverse1
// Reverse1 字符(学习之前以为万事大吉但是实际上这里仅限于utf-8的字符)
func Reverse1(input string) string {bytes : []rune(input)for i, j : 0, len(bytes)-1; i len(bytes)/2; i, j i1, j-1 {bytes[i], bytes[j] bytes[j], bytes[i]}return string(bytes)
}4. 再次在main中测试
package mainimport (fmt
)// Reverse 字节 反转字符串
func Reverse(input string) string {bytes : []byte(input)for i, j : 0, len(bytes)-1; i len(bytes)/2; i, j i1, j-1 {bytes[i], bytes[j] bytes[j], bytes[i]}return string(bytes)
}// Reverse1 字符(学习之前以为万事大吉但是实际上这里仅限于utf-8的字符)
func Reverse1(input string) string {bytes : []rune(input)for i, j : 0, len(bytes)-1; i len(bytes)/2; i, j i1, j-1 {bytes[i], bytes[j] bytes[j], bytes[i]}return string(bytes)
}func main() {input : hello, world , java页, go bigdatafirstRev : Reverse(input)secondRev : Reverse(firstRev)fmt.Printf(原始数据: %q\n, input)fmt.Printf(第一次反转的数据: %q\n, firstRev)fmt.Printf(反转数据再次反转的数据: %q\n, secondRev)firstRev1 : Reverse1(input)secondRev1 : Reverse1(firstRev1)fmt.Printf(第一次反转的数据: %q\n, firstRev1)fmt.Printf(反转数据再次反转的数据: %q\n, secondRev1)
}5. 经过测试后个例反转的效果是正确。但是个例毕竟还是个例。官网里面存在测试的使用教程。下面继续吧。 go官方推荐测试方式一
单元unit 测试
1. 新建一个go文件要求文件命名为 待测试文件名 _test.go
我待测试文件名为fuzzingToLearn.go 所以要新建的文件名为fuzzingToLearn_test.go文件存在两个函数需要待验证所以这里也编写了两个函数注意事项 测试方法名字规范: Test$functionName其中 f u n c t i o n N a m e 的首字母要改写为大写 ! 这里的 functionName的首字母要改写为大写!这里的 functionName的首字母要改写为大写!这里的functionName没有局限名字保证首字母大写即可
package mainimport (testingunicode/utf8
)// 测试字节反转
func TestReverse(t *testing.T) {testcases : []struct {in, want string}{{Hello, world, dlrow ,olleH},{ , },{!123456, 654321!},}for _, tc : range testcases {rev : Reverse(tc.in)if rev ! tc.want {t.Errorf(Reverse: %q, want %q, rev, tc.want)}}
}// 测试字符反转
func TestReverse1(t *testing.T) {testcases : []struct {in, want string}{{页Hello, world, dlrow ,olleH页},{ , },{!123456, 654321!},}for _, tc : range testcases {rev : Reverse1(tc.in)if rev ! tc.want {t.Errorf(Reverse: %q, want %q, rev, tc.want)}}
}2. 进行测试验证
切换到对应路径在终端上运行go test -v命令这个命令是测试所有的方法的也有测试单个方法的go test -v -test.run $测试方法名Windows的cmd和powershell都可以运行其它操作系统的就不说了结果展示
PS D:\codes\go\goland-setting\test\fuzzing ls目录: D:\codes\go\goland-setting\test\fuzzingMode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 2023/12/6 22:37 1661 fuzzingToLearn.go
-a---- 2023/12/6 23:01 2197 fuzzingToLearn_test.goPS D:\codes\go\goland-setting\test\fuzzing go test -v
warning: GOPATH set to GOROOT (D:\install\go_install) has no effectRUN TestReverse
--- PASS: TestReverse (0.00s)RUN TestReverse1
--- PASS: TestReverse1 (0.00s)
PASS
ok goland-setting/test/fuzzing 0.043s3. unit单元测试局限性
每个输入必须由开发人员添加到测试中
4. unit单元测试的优点
可以在线测试不像在main方法中进行测试的方式需要停止程序然后还要进行注释原有的代码官方是推荐的但是这个不够精确需要精确就使用fuzz测试吧
fuzz模糊测试 fuzz测试函数以Fuzz开头而不是Test开头 方法参数和unit单元测试也不同fuzz模糊测试为:f *testing.F 为了方便fuzz模糊测试直接在fuzzingToLearn_test.go文件进行
1. 在fuzzingToLearn_test文件中添加模糊测试的代码 - 两个方法测试
// FuzzReverse fuzz测试 字节-字符串反转
func FuzzReverse(f *testing.F) {testcases : []string{Hello, world, , !123456}for _, tc : range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}//对于字符会出错f.Fuzz(func(t *testing.T, orig string) {rev : Reverse(orig)doubleRev : Reverse(rev)if orig ! doubleRev {t.Errorf(Before: %q, after: %q, orig, doubleRev)}if utf8.ValidString(orig) !utf8.ValidString(rev) {t.Errorf(Reverse produced invalid UTF-8 string %q, rev)}})
}// FuzzReverse1 fuzz测试 字符-字符串反转
func FuzzReverse1(f *testing.F) {testcases : []string{Hello, world, , !123456}for _, tc : range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}//非utf-8会出错f.Fuzz(func(t *testing.T, orig string) {rev : Reverse1(orig)doubleRev : Reverse1(rev)t.Logf(Number of runes: orig%d, rev%d, doubleRev%d, utf8.RuneCountInString(orig),utf8.RuneCountInString(rev), utf8.RuneCountInString(doubleRev))if orig ! doubleRev {t.Errorf(Before: %q, after: %q, orig, doubleRev)}if utf8.ValidString(orig) !utf8.ValidString(rev) {t.Errorf(Reverse produced invalid UTF-8 string %q, rev)}})
}2. 终端运行测试
注意事项 使用fuzz模糊化时你不能预测预期的输出因为你不能控制输入
1. 使用终端先使用run test验证是否通过
PS D:\codes\go\goland-setting\test\fuzzing go test
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
PASS
ok goland-setting/test/fuzzing 0.041s
2. 使用fuzz模糊测试验证查看任何随机生成的字符串输入是否会导致失败
# 第一次出错
PS D:\codes\go\goland-setting\test\fuzzing go test -fuzzFuzz
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
testing: will not fuzz, -fuzz matches more than one fuzz test: [FuzzReverse FuzzReverse1]
FAIL
exit status 1
FAIL goland-setting/test/fuzzing 0.041s# 原因是一个文件只能有一个fuzz的测试例子。注释FuzzReverse1方法测试PS D:\codes\go\goland-setting\test\fuzzing go test -fuzzFuzz
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
fuzz: elapsed: 0s, gathering baseline coverage: 0/58 completed
failure while testing seed corpus entry: FuzzReverse/34d11aca3c8d1e0d
fuzz: elapsed: 0s, gathering baseline coverage: 2/58 completed
--- FAIL: FuzzReverse (0.09s)--- FAIL: FuzzReverse (0.00s)fuzzingToLearn_test.go:54: Reverse produced invalid UTF-8 string \xab\xb0\xe7FAIL
exit status 1
FAIL goland-setting/test/fuzzing 0.134s
# 结果是不通过即测试失败结果测试不通过即有bug 查看文件同目录产生了新的文件 文件内容为 go test fuzz v1
string(簫)这里指的是簫不通过方法的测试。但是我们知道这个方法对于汉字就是有bug我们先跳过看一下第二个方法是否可行。 testdata目录可以删除的。但建议等完全测试后再删除
3. 使用fuzz模糊测试FuzzReverse1方法代码改动
由于一个文件不能存在多个fuzz方法所以先注释上面的FuzzReverse函数的代码,打开FuzzReverse1函数的方法
// FuzzReverse1 fuzz测试 字符-字符串反转
func FuzzReverse1(f *testing.F) {testcases : []string{Hello, world, , !123456}for _, tc : range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}//非utf-8会出错f.Fuzz(func(t *testing.T, orig string) {rev : Reverse1(orig)doubleRev : Reverse1(rev)t.Logf(Number of runes: orig%d, rev%d, doubleRev%d, utf8.RuneCountInString(orig),utf8.RuneCountInString(rev), utf8.RuneCountInString(doubleRev))if orig ! doubleRev {t.Errorf(Before: %q, after: %q, orig, doubleRev)}if utf8.ValidString(orig) !utf8.ValidString(rev) {t.Errorf(Reverse produced invalid UTF-8 string %q, rev)}})
}4. 使用fuzz验证
PS D:\codes\go\goland-setting\test\fuzzing go test -fuzzFuzz
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
fuzz: elapsed: 0s, gathering baseline coverage: 0/3 completed
fuzz: elapsed: 0s, gathering baseline coverage: 3/3 completed, now fuzzing with 16 workers
fuzz: minimizing 42-byte failing input file
fuzz: elapsed: 0s, minimizing
--- FAIL: FuzzReverse1 (0.15s)--- FAIL: FuzzReverse1 (0.00s)fuzzingToLearn_test.go:70: Number of runes: orig1, rev1, doubleRev1fuzzingToLearn_test.go:73: Before: \x86, after: Failing input written to testdata\fuzz\FuzzReverse1\0cca6a19caba34b5To re-run:go test -runFuzzReverse1/0cca6a19caba34b5
FAIL
exit status 1
FAIL goland-setting/test/fuzzing 0.525s
# 还是出错了。而且前后两个值不同同样的还是生成了文件 说明FuzzReverse1函数也有bug
诊断代码 经过了解 在Go语言中字符串是一个只读的字节片可以包含非UTF-8有效的字节。原始字符串是一个字节切片其中有一个字节 \x86 。当输入字符串被设置为 []rune 时Go语言将字节切片编码为UTF-8并将字节替换为UTF-8字符。当我们将替换UTF-8字符与输入字节片进行比较时它们显然不相等。 所以我们需要修改我们的函数代码。但是此处为了保留之前的代码就直接增加一个函数即可。添加到fuzzingToLearn.go文件然后再再进行测试该方法即可。
增加函数Reverse2,内容如下
// Reverse2 排除不是utf-8字符
func Reverse2(input string) (string, error) {if !utf8.ValidString(input) {return input, errors.New(input is not valid UTF-8)}runes : []rune(input)for i, j : 0, len(runes)-1; i len(runes)/2; i, j i1, j-1 {runes[i], runes[j] runes[j], runes[i]}return string(runes), nil
}fuzzingToLearn_test.go文件添加对应的fuzz模糊测试函数FuzzReverse2
// 注释FuzzReverse1(f *testing.F)方法增加下面内容
// fuzz测试 字符串反转 字符排除非utf-8字符
func FuzzReverse2(f *testing.F) {testcases : []string{Hello, world, , !123456}for _, tc : range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}f.Fuzz(func(t *testing.T, orig string) {rev, err1 : Reverse2(orig)if err1 ! nil {return // 可以调用 t.Skip()}doubleRev, err2 : Reverse2(rev)if err2 ! nil {return // 可以调用 t.Skip()}if orig ! doubleRev {t.Errorf(Before: %q, after: %q, orig, doubleRev)}if utf8.ValidString(orig) !utf8.ValidString(rev) {t.Errorf(Reverse produced invalid UTF-8 string %q, rev)}})
} 这里就跳过了前面所介绍的两种测试验证直接进行fuzz模糊测试 这里是只先验证错误的情况即新增加的testdata目录下的文件内容情况。使用go test -run命令
PS D:\codes\go\goland-setting\test\fuzzing go test -runFuzzReverse1/0cca6a19caba34b5
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
testing: warning: no tests to run
PASS
ok goland-setting/test/fuzzing 0.357s
# success再次运行go test -fuzzFuzz
PS D:\codes\go\goland-setting\test\fuzzing go test -fuzzFuzz
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
fuzz: elapsed: 0s, gathering baseline coverage: 0/3 completed
fuzz: elapsed: 0s, gathering baseline coverage: 3/3 completed, now fuzzing with 16 workers
fuzz: elapsed: 3s, execs: 1212471 (404034/sec), new interesting: 32 (total: 35)
fuzz: elapsed: 6s, execs: 2590247 (458435/sec), new interesting: 35 (total: 38)
fuzz: elapsed: 9s, execs: 3933396 (448061/sec), new interesting: 35 (total: 38)
fuzz: elapsed: 12s, execs: 5262110 (442525/sec), new interesting: 35 (total: 38)
fuzz: elapsed: 15s, execs: 6555446 (431581/sec), new interesting: 35 (total: 38)
fuzz: elapsed: 18s, execs: 7789113 (411424/sec), new interesting: 36 (total: 39)
fuzz: elapsed: 21s, execs: 9042454 (416817/sec), new interesting: 36 (total: 39)
fuzz: elapsed: 22s, execs: 9511996 (407607/sec), new interesting: 36 (total: 39)
PASS
ok goland-setting/test/fuzzing 22.581s
go test -fuzzFuzz不会自动停止需要CTRL c来停止或者运行go test -fuzzFuzz -fuzztime 20s来指定20s后结束
PS D:\codes\go\goland-setting\test\fuzzing go test -fuzzFuzz -fuzztime 20s
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
fuzz: elapsed: 0s, gathering baseline coverage: 0/43 completed
fuzz: elapsed: 0s, gathering baseline coverage: 43/43 completed, now fuzzing with 16 workers
fuzz: elapsed: 3s, execs: 1332436 (442300/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 6s, execs: 2701841 (458040/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 9s, execs: 4096713 (463975/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 12s, execs: 5449685 (451464/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 15s, execs: 6755971 (435062/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 18s, execs: 8075349 (439717/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 20s, execs: 8927301 (403763/sec), new interesting: 0 (total: 43)
PASS
ok goland-setting/test/fuzzing 20.214s
end
所有的代码
fuzzingToLearn.go
package mainimport (errorsfmtunicode/utf8
)// Reverse 字节 反转字符串
func Reverse(input string) string {bytes : []byte(input)for i, j : 0, len(bytes)-1; i len(bytes)/2; i, j i1, j-1 {bytes[i], bytes[j] bytes[j], bytes[i]}return string(bytes)
}// Reverse1 字符(学习之前以为万事大吉但是实际上这里仅限于utf-8的字符)
func Reverse1(input string) string {bytes : []rune(input)for i, j : 0, len(bytes)-1; i len(bytes)/2; i, j i1, j-1 {bytes[i], bytes[j] bytes[j], bytes[i]}return string(bytes)
}// Reverse2 排除不是utf-8字符
func Reverse2(input string) (string, error) {if !utf8.ValidString(input) {return input, errors.New(input is not valid UTF-8)}runes : []rune(input)for i, j : 0, len(runes)-1; i len(runes)/2; i, j i1, j-1 {runes[i], runes[j] runes[j], runes[i]}return string(runes), nil
}func main() {input : hello, world , java页, go bigdatafirstRev : Reverse(input)secondRev : Reverse(firstRev)fmt.Printf(原始数据: %q\n, input)fmt.Printf(第一次反转的数据: %q\n, firstRev)fmt.Printf(反转数据再次反转的数据: %q\n, secondRev)firstRev1 : Reverse1(input)secondRev1 : Reverse1(firstRev1)fmt.Printf(第一次反转的数据: %q\n, firstRev1)fmt.Printf(反转数据再次反转的数据: %q\n, secondRev1)firstRev2, firstRev2Err : Reverse2(input)secondRev2, secondRevErr : Reverse2(firstRev2)fmt.Printf(第一次反转的数据: %q, err: %v\n, firstRev2, firstRev2Err)fmt.Printf(反转数据再次反转的数据: %q, err: %v\n, secondRev2, secondRevErr)
}
fuzzingToLearn_test.go
package mainimport (testingunicode/utf8
)func TestReverse(t *testing.T) {testcases : []struct {in, want string}{{Hello, world, dlrow ,olleH},{ , },{!123456, 654321!},}for _, tc : range testcases {rev : Reverse(tc.in)if rev ! tc.want {t.Errorf(Reverse: %q, want %q, rev, tc.want)}}
}func TestReverse1(t *testing.T) {testcases : []struct {in, want string}{{页Hello, world, dlrow ,olleH页},{ , },{!123456, 654321!},}for _, tc : range testcases {rev : Reverse1(tc.in)if rev ! tc.want {t.Errorf(Reverse: %q, want %q, rev, tc.want)}}
}// FuzzReverse fuzz测试 字节-字符串反转
//func FuzzReverse(f *testing.F) {
// testcases : []string{Hello, world, , !123456}
// for _, tc : range testcases {
// f.Add(tc) // Use f.Add to provide a seed corpus
// }
// //对于字符会出错
// f.Fuzz(func(t *testing.T, orig string) {
// rev : Reverse(orig)
// doubleRev : Reverse(rev)
// if orig ! doubleRev {
// t.Errorf(Before: %q, after: %q, orig, doubleRev)
// }
// if utf8.ValidString(orig) !utf8.ValidString(rev) {
// t.Errorf(Reverse produced invalid UTF-8 string %q, rev)
// }
// })
//}// FuzzReverse1 fuzz测试 字符-字符串反转
//func FuzzReverse1(f *testing.F) {
// testcases : []string{Hello, world, , !123456}
// for _, tc : range testcases {
// f.Add(tc) // Use f.Add to provide a seed corpus
// }
//
// //非utf-8会出错
// f.Fuzz(func(t *testing.T, orig string) {
// rev : Reverse1(orig)
// doubleRev : Reverse1(rev)
// t.Logf(Number of runes: orig%d, rev%d, doubleRev%d, utf8.RuneCountInString(orig),
// utf8.RuneCountInString(rev), utf8.RuneCountInString(doubleRev))
// if orig ! doubleRev {
// t.Errorf(Before: %q, after: %q, orig, doubleRev)
// }
// if utf8.ValidString(orig) !utf8.ValidString(rev) {
// t.Errorf(Reverse produced invalid UTF-8 string %q, rev)
// }
// })
//
//}// fuzz测试 字符串反转 字符排除非utf-8字符
func FuzzReverse2(f *testing.F) {testcases : []string{Hello, world, , !123456}for _, tc : range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}f.Fuzz(func(t *testing.T, orig string) {rev, err1 : Reverse2(orig)if err1 ! nil {return // 可以调用 t.Skip()}doubleRev, err2 : Reverse2(rev)if err2 ! nil {return // 可以调用 t.Skip()}if orig ! doubleRev {t.Errorf(Before: %q, after: %q, orig, doubleRev)}if utf8.ValidString(orig) !utf8.ValidString(rev) {t.Errorf(Reverse produced invalid UTF-8 string %q, rev)}})
}
