2022-08-04 06:59:33 +00:00
<!DOCTYPE HTML>
< html lang = "zh" class = "sidebar-visible no-js light" >
< head >
<!-- Book generated using mdBook -->
< meta charset = "UTF-8" >
< title > 测试函数 - Go语言圣经< / title >
<!-- Custom HTML head -->
< meta content = "text/html; charset=utf-8" http-equiv = "Content-Type" >
< meta name = "description" content = "<The Go Programming Language>中文版" >
< meta name = "viewport" content = "width=device-width, initial-scale=1" >
< meta name = "theme-color" content = "#ffffff" / >
< link rel = "icon" href = "../favicon.svg" >
< link rel = "shortcut icon" href = "../favicon.png" >
< link rel = "stylesheet" href = "../css/variables.css" >
< link rel = "stylesheet" href = "../css/general.css" >
< link rel = "stylesheet" href = "../css/chrome.css" >
< link rel = "stylesheet" href = "../css/print.css" media = "print" >
<!-- Fonts -->
< link rel = "stylesheet" href = "../FontAwesome/css/font-awesome.css" >
< link rel = "stylesheet" href = "../fonts/fonts.css" >
<!-- Highlight.js Stylesheets -->
< link rel = "stylesheet" href = "../highlight.css" >
< link rel = "stylesheet" href = "../tomorrow-night.css" >
< link rel = "stylesheet" href = "../ayu-highlight.css" >
<!-- Custom theme stylesheets -->
< link rel = "stylesheet" href = "../style.css" >
< / head >
< body >
<!-- Provide site root to javascript -->
< script type = "text/javascript" >
var path_to_root = "../";
var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "navy" : "light";
< / script >
<!-- Work around some values being stored in localStorage wrapped in quotes -->
< script type = "text/javascript" >
try {
var theme = localStorage.getItem('mdbook-theme');
var sidebar = localStorage.getItem('mdbook-sidebar');
if (theme.startsWith('"') & & theme.endsWith('"')) {
localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
}
if (sidebar.startsWith('"') & & sidebar.endsWith('"')) {
localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
}
} catch (e) { }
< / script >
<!-- Set the theme before any content is loaded, prevents flash -->
< script type = "text/javascript" >
var theme;
try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
if (theme === null || theme === undefined) { theme = default_theme; }
var html = document.querySelector('html');
html.classList.remove('no-js')
html.classList.remove('light')
html.classList.add(theme);
html.classList.add('js');
< / script >
<!-- Hide / unhide sidebar before it is displayed -->
< script type = "text/javascript" >
var html = document.querySelector('html');
var sidebar = 'hidden';
if (document.body.clientWidth >= 1080) {
try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
sidebar = sidebar || 'visible';
}
html.classList.remove('sidebar-visible');
html.classList.add("sidebar-" + sidebar);
< / script >
< nav id = "sidebar" class = "sidebar" aria-label = "Table of contents" >
< div class = "sidebar-scrollbox" >
2023-06-26 17:30:52 +00:00
< ol class = "chapter" > < li class = "chapter-item expanded affix " > < a href = "../index.html" > Go语言圣经< / a > < / li > < li class = "chapter-item expanded affix " > < a href = "../preface-zh.html" > 译者序< / a > < / li > < li class = "chapter-item expanded affix " > < a href = "../preface.html" > 前言< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch1/ch1.html" > < strong aria-hidden = "true" > 1.< / strong > 入门< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "../ch1/ch1-01.html" > < strong aria-hidden = "true" > 1.1.< / strong > Hello, World< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch1/ch1-02.html" > < strong aria-hidden = "true" > 1.2.< / strong > 命令行参数< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch1/ch1-03.html" > < strong aria-hidden = "true" > 1.3.< / strong > 查找重复的行< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch1/ch1-04.html" > < strong aria-hidden = "true" > 1.4.< / strong > GIF动画< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch1/ch1-05.html" > < strong aria-hidden = "true" > 1.5.< / strong > 获取URL< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch1/ch1-06.html" > < strong aria-hidden = "true" > 1.6.< / strong > 并发获取多个URL< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch1/ch1-07.html" > < strong aria-hidden = "true" > 1.7.< / strong > Web服务< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch1/ch1-08.html" > < strong aria-hidden = "true" > 1.8.< / strong > 本章要点< / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "../ch2/ch2.html" > < strong aria-hidden = "true" > 2.< / strong > 程序结构< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "../ch2/ch2-01.html" > < strong aria-hidden = "true" > 2.1.< / strong > 命名< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch2/ch2-02.html" > < strong aria-hidden = "true" > 2.2.< / strong > 声明< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch2/ch2-03.html" > < strong aria-hidden = "true" > 2.3.< / strong > 变量< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch2/ch2-04.html" > < strong aria-hidden = "true" > 2.4.< / strong > 赋值< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch2/ch2-05.html" > < strong aria-hidden = "true" > 2.5.< / strong > 类型< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch2/ch2-06.html" > < strong aria-hidden = "true" > 2.6.< / strong > 包和文件< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch2/ch2-07.html" > < strong aria-hidden = "true" > 2.7.< / strong > 作用域< / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "../ch3/ch3.html" > < strong aria-hidden = "true" > 3.< / strong > 基础数据类型< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "../ch3/ch3-01.html" > < strong aria-hidden = "true" > 3.1.< / strong > 整型< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch3/ch3-02.html" > < strong aria-hidden = "true" > 3.2.< / strong > 浮点数< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch3/ch3-03.html" > < strong aria-hidden = "true" > 3.3.< / strong > 复数< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch3/ch3-04.html" > < strong aria-hidden = "true" > 3.4.< / strong > 布尔型< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch3/ch3-05.html" > < strong aria-hidden = "true" > 3.5.< / strong > 字符串< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch3/ch3-06.html" > < strong aria-hidden = "true" > 3.6.< / strong > 常量< / a > < / li > < / ol > < / li > < li class = "chapter-item expanded " > < a href = "../ch4/ch4.html" > < strong aria-hidden = "true" > 4.< / strong > 复合数据类型< / a > < / li > < li > < ol class = "section" > < li class = "chapter-item expanded " > < a href = "../ch4/ch4-01.html" > < strong aria-hidden = "true" > 4.1.< / strong > 数组< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch4/ch4-02.html" > < strong aria-hidden = "true" > 4.2.< / strong > Slice< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch4/ch4-03.html" > < strong aria-hidden = "true" > 4.3.< / strong > Map< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch4/ch4-04.html" > < strong aria-hidden = "true" > 4.4.< / strong > 结构体< / a > < / li > < li class = "chapter-item expanded " > < a href = "../ch4/ch4-05.html" > < strong aria-hidden = "true" > 4.5.< / strong > JSON< /
2022-08-04 06:59:33 +00:00
< div id = "sidebar-resize-handle" class = "sidebar-resize-handle" > < / div >
< / nav >
< div id = "page-wrapper" class = "page-wrapper" >
< div class = "page" >
< div id = "menu-bar-hover-placeholder" > < / div >
< div id = "menu-bar" class = "menu-bar sticky bordered" >
< div class = "left-buttons" >
< button id = "sidebar-toggle" class = "icon-button" type = "button" title = "Toggle Table of Contents" aria-label = "Toggle Table of Contents" aria-controls = "sidebar" >
< i class = "fa fa-bars" > < / i >
< / button >
< button id = "theme-toggle" class = "icon-button" type = "button" title = "Change theme" aria-label = "Change theme" aria-haspopup = "true" aria-expanded = "false" aria-controls = "theme-list" >
< i class = "fa fa-paint-brush" > < / i >
< / button >
< ul id = "theme-list" class = "theme-popup" aria-label = "Themes" role = "menu" >
< li role = "none" > < button role = "menuitem" class = "theme" id = "light" > Light (default)< / button > < / li >
< li role = "none" > < button role = "menuitem" class = "theme" id = "rust" > Rust< / button > < / li >
< li role = "none" > < button role = "menuitem" class = "theme" id = "coal" > Coal< / button > < / li >
< li role = "none" > < button role = "menuitem" class = "theme" id = "navy" > Navy< / button > < / li >
< li role = "none" > < button role = "menuitem" class = "theme" id = "ayu" > Ayu< / button > < / li >
< / ul >
< button id = "search-toggle" class = "icon-button" type = "button" title = "Search. (Shortkey: s)" aria-label = "Toggle Searchbar" aria-expanded = "false" aria-keyshortcuts = "S" aria-controls = "searchbar" >
< i class = "fa fa-search" > < / i >
< / button >
< / div >
< h1 class = "menu-title" > Go语言圣经< / h1 >
< div class = "right-buttons" >
< a href = "../print.html" title = "Print this book" aria-label = "Print this book" >
< i id = "print-button" class = "fa fa-print" > < / i >
< / a >
< a href = "https://github.com/gopl-zh/gopl-zh.github.com" title = "Git repository" aria-label = "Git repository" >
< i id = "git-repository-button" class = "fa fa-github" > < / i >
< / a >
< a href = "https://github.com/gopl-zh/gopl-zh.github.com/edit/master/./ch11/ch11-02.md" title = "Suggest an edit" aria-label = "Suggest an edit" >
< i id = "git-edit-button" class = "fa fa-edit" > < / i >
< / a >
< / div >
< / div >
< div id = "search-wrapper" class = "hidden" >
< form id = "searchbar-outer" class = "searchbar-outer" >
< input type = "search" id = "searchbar" name = "searchbar" placeholder = "Search this book ..." aria-controls = "searchresults-outer" aria-describedby = "searchresults-header" >
< / form >
< div id = "searchresults-outer" class = "searchresults-outer hidden" >
< div id = "searchresults-header" class = "searchresults-header" > < / div >
< ul id = "searchresults" >
< / ul >
< / div >
< / div >
<!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
< script type = "text/javascript" >
document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
});
< / script >
< div id = "content" class = "content" >
<!-- Page table of contents -->
< div class = "sidetoc" > < nav class = "pagetoc" > < / nav > < / div >
< main >
<!-- 头部 -->
< ul dir = "auto" >
2024-06-12 07:20:07 +00:00
< li > < em > Go语言圣经读书笔记(挖坑中...): < a href = "https://github.com/chai2010/gopl-notes-zh" > https://github.com/chai2010/gopl-notes-zh< / a > < / em > < / li >
< li > < em > 凹语言(Go实现, 面向WASM设计): < a href = "https://github.com/wa-lang/wa" > https://github.com/wa-lang/wa< / a > < / em > < / li >
2023-06-26 17:46:27 +00:00
< / ul >
2022-08-04 06:59:33 +00:00
< hr >
< h2 id = "112-测试函数" > < a class = "header" href = "#112-测试函数" > 11.2. 测试函数< / a > < / h2 >
< p > 每个测试函数必须导入testing包。测试函数有如下的签名： < / p >
< pre > < code class = "language-Go" > func TestName(t *testing.T) {
// ...
}
< / code > < / pre >
< p > 测试函数的名字必须以Test开头， ： < / p >
< pre > < code class = "language-Go" > func TestSin(t *testing.T) { /* ... */ }
func TestCos(t *testing.T) { /* ... */ }
func TestLog(t *testing.T) { /* ... */ }
< / code > < / pre >
< p > 其中t参数用于报告测试失败和附加的日志信息。让我们定义一个实例包gopl.io/ch11/word1， （ ； ） < / p >
< p > < u > < i > gopl.io/ch11/word1< / i > < / u > < / p >
< pre > < code class = "language-Go" > // Package word provides utilities for word games.
package word
// IsPalindrome reports whether s reads the same forward and backward.
// (Our first attempt.)
func IsPalindrome(s string) bool {
for i := range s {
if s[i] != s[len(s)-1-i] {
return false
}
}
return true
}
< / code > < / pre >
< p > 在相同的目录下， ， ： < / p >
< pre > < code class = "language-Go" > package word
import " testing"
func TestPalindrome(t *testing.T) {
if !IsPalindrome(" detartrated" ) {
t.Error(`IsPalindrome(" detartrated" ) = false`)
}
if !IsPalindrome(" kayak" ) {
t.Error(`IsPalindrome(" kayak" ) = false`)
}
}
func TestNonPalindrome(t *testing.T) {
if IsPalindrome(" palindrome" ) {
t.Error(`IsPalindrome(" palindrome" ) = true`)
}
}
< / code > < / pre >
< p > < code > go test< / code > 命令如果没有参数指定包那么将默认采用当前目录对应的包（和< code > go build< / code > 命令一样）。我们可以用下面的命令构建和运行测试。< / p >
< pre > < code > $ cd $GOPATH/src/gopl.io/ch11/word1
$ go test
ok gopl.io/ch11/word1 0.008s
< / code > < / pre >
< p > 结果还比较满意，我们运行了这个程序， 不过没有提前退出是因为还没有遇到BUG报告。不过一个法国名为“Noelle Eve Elleon”的用户会抱怨IsPalindrome函数不能识别“été”。另外一个来自美国中部用户的抱怨则是不能识别“A man, a plan, a canal: Panama.”。执行特殊和小的BUG报告为我们提供了新的更自然的测试用例。< / p >
< pre > < code class = "language-Go" > func TestFrenchPalindrome(t *testing.T) {
if !IsPalindrome(" été" ) {
t.Error(`IsPalindrome(" été" ) = false`)
}
}
func TestCanalPalindrome(t *testing.T) {
input := " A man, a plan, a canal: Panama"
if !IsPalindrome(input) {
t.Errorf(`IsPalindrome(%q) = false`, input)
}
}
< / code > < / pre >
< p > 为了避免两次输入较长的字符串， < / p >
< p > 当添加了这两个测试用例之后，< code > go test< / code > 返回了测试失败的信息。< / p >
< pre > < code > $ go test
--- FAIL: TestFrenchPalindrome (0.00s)
word_test.go:28: IsPalindrome(" été" ) = false
--- FAIL: TestCanalPalindrome (0.00s)
word_test.go:35: IsPalindrome(" A man, a plan, a canal: Panama" ) = false
FAIL
FAIL gopl.io/ch11/word1 0.014s
< / code > < / pre >
< p > 先编写测试用例并观察到测试用例触发了和用户报告的错误相同的描述是一个好的测试习惯。只有这样，我们才能定位我们要真正解决的问题。< / p >
< p > 先写测试用例的另外的好处是，运行测试通常会比手工描述报告的处理更快，这让我们可以进行快速地迭代。如果测试集有很多运行缓慢的测试，我们可以通过只选择运行某些特定的测试来加快测试速度。< / p >
< p > 参数< code > -v< / code > 可用于打印每个测试函数的名字和运行时间：< / p >
< pre > < code > $ go test -v
=== RUN TestPalindrome
--- PASS: TestPalindrome (0.00s)
=== RUN TestNonPalindrome
--- PASS: TestNonPalindrome (0.00s)
=== RUN TestFrenchPalindrome
--- FAIL: TestFrenchPalindrome (0.00s)
word_test.go:28: IsPalindrome(" été" ) = false
=== RUN TestCanalPalindrome
--- FAIL: TestCanalPalindrome (0.00s)
word_test.go:35: IsPalindrome(" A man, a plan, a canal: Panama" ) = false
FAIL
exit status 1
FAIL gopl.io/ch11/word1 0.017s
< / code > < / pre >
< p > 参数< code > -run< / code > 对应一个正则表达式，只有测试函数名被它正确匹配的测试函数才会被< code > go test< / code > 测试命令运行：< / p >
< pre > < code > $ go test -v -run=" French|Canal"
=== RUN TestFrenchPalindrome
--- FAIL: TestFrenchPalindrome (0.00s)
word_test.go:28: IsPalindrome(" été" ) = false
=== RUN TestCanalPalindrome
--- FAIL: TestCanalPalindrome (0.00s)
word_test.go:35: IsPalindrome(" A man, a plan, a canal: Panama" ) = false
FAIL
exit status 1
FAIL gopl.io/ch11/word1 0.014s
< / code > < / pre >
< p > 当然，一旦我们已经修复了失败的测试用例，在我们提交代码更新之前，我们应该以不带参数的< code > go test< / code > 命令运行全部的测试用例，以确保修复失败测试的同时没有引入新的问题。< / p >
< p > 我们现在的任务就是修复这些错误。简要分析后发现第一个BUG的原因是我们采用了 byte而不是rune序列， < / p >
< p > 针对上述两个BUG， ： < / p >
< p > < u > < i > gopl.io/ch11/word2< / i > < / u > < / p >
< pre > < code class = "language-Go" > // Package word provides utilities for word games.
package word
import " unicode"
// IsPalindrome reports whether s reads the same forward and backward.
// Letter case is ignored, as are non-letters.
func IsPalindrome(s string) bool {
var letters []rune
for _, r := range s {
if unicode.IsLetter(r) {
letters = append(letters, unicode.ToLower(r))
}
}
for i := range letters {
if letters[i] != letters[len(letters)-1-i] {
return false
}
}
return true
}
< / code > < / pre >
< p > 同时我们也将之前的所有测试数据合并到了一个测试中的表格中。< / p >
< pre > < code class = "language-Go" > func TestIsPalindrome(t *testing.T) {
var tests = []struct {
input string
want bool
}{
{" " , true},
{" a" , true},
{" aa" , true},
{" ab" , false},
{" kayak" , true},
{" detartrated" , true},
{" A man, a plan, a canal: Panama" , true},
{" Evil I did dwell; lewd did I live." , true},
{" Able was I ere I saw Elba" , true},
{" été" , true},
{" Et se resservir, ivresse reste." , true},
{" palindrome" , false}, // non-palindrome
{" desserts" , false}, // semi-palindrome
}
for _, test := range tests {
if got := IsPalindrome(test.input); got != test.want {
t.Errorf(" IsPalindrome(%q) = %v" , test.input, got)
}
}
}
< / code > < / pre >
< p > 现在我们的新测试都通过了：< / p >
< pre > < code > $ go test gopl.io/ch11/word2
ok gopl.io/ch11/word2 0.015s
< / code > < / pre >
< p > 这种表格驱动的测试在Go语言中很常见。我们可以很容易地向表格添加新的测试数据， ， < / p >
< p > 失败测试的输出并不包括调用t.Errorf时刻的堆栈调用信息。和其他编程语言或测试框架的assert断言不同， ， ， < / p >
< p > 如果我们真的需要停止测试， ， < / p >
< p > 测试失败的信息一般的形式是“f(x) = y, want z”， ， ， ， ， ， ， < / p >
< p > < strong > 练习 11.1:< / strong > 为4.3节中的charcount程序编写测试。< / p >
< p > < strong > 练习 11.2:< / strong > 为（ ） ， ， < / p >
< h3 id = "1121-随机测试" > < a class = "header" href = "#1121-随机测试" > 11.2.1. 随机测试< / a > < / h3 >
< p > 表格驱动的测试便于构造基于精心挑选的测试数据的测试用例。另一种测试思路是随机测试，也就是通过构造更广泛的随机输入来测试探索函数的行为。< / p >
< p > 那么对于一个随机的输入，我们如何能知道希望的输出结果呢？这里有两种处理策略。第一个是编写另一个对照函数，使用简单和清晰的算法，虽然效率较低但是行为和要测试的函数是一致的，然后针对相同的随机输入检查两者的输出结果。第二种是生成的随机输入的数据遵循特定的模式，这样我们就可以知道期望的输出的模式。< / p >
< p > 下面的例子使用的是第二种方法： < / p >
< pre > < code class = "language-Go" > import " math/rand"
// randomPalindrome returns a palindrome whose length and contents
// are derived from the pseudo-random number generator rng.
func randomPalindrome(rng *rand.Rand) string {
n := rng.Intn(25) // random length up to 24
runes := make([]rune, n)
for i := 0; i < (n+1)/2; i++ {
r := rune(rng.Intn(0x1000)) // random rune up to '\u0999'
runes[i] = r
runes[n-1-i] = r
}
return string(runes)
}
func TestRandomPalindromes(t *testing.T) {
// Initialize a pseudo-random number generator.
seed := time.Now().UTC().UnixNano()
t.Logf(" Random seed: %d" , seed)
rng := rand.New(rand.NewSource(seed))
for i := 0; i < 1000; i++ {
p := randomPalindrome(rng)
if !IsPalindrome(p) {
t.Errorf(" IsPalindrome(%q) = false" , p)
}
}
}
< / code > < / pre >
< p > 虽然随机测试会有不确定因素， ， ， ， ， ， （ ） ， < / p >
< p > 通过使用当前时间作为随机种子，在整个过程中的每次运行测试命令时都将探索新的随机数据。如果你使用的是定期运行的自动化测试集成系统，随机测试将特别有价值。< / p >
< p > < strong > 练习 11.3:< / strong > TestRandomPalindromes测试函数只测试了回文字符串。编写新的随机测试生成器， < / p >
< p > < strong > 练习 11.4:< / strong > 修改randomPalindrome函数， < / p >
< p > 译者注：< strong > 拓展阅读< / strong > 感兴趣的读者可以再了解一下go-fuzz< / p >
< h3 id = "1122-测试一个命令" > < a class = "header" href = "#1122-测试一个命令" > 11.2.2. 测试一个命令< / a > < / h3 >
< p > 对于测试包< code > go test< / code > 是一个有用的工具，但是稍加努力我们也可以用它来测试可执行程序。如果一个包的名字是 main， ， < / p >
< p > 让我们为2.3.2节的echo程序编写一个测试。我们先将程序拆分为两个函数： ， < / p >
< p > < u > < i > gopl.io/ch11/echo< / i > < / u > < / p >
< pre > < code class = "language-Go" > // Echo prints its command-line arguments.
package main
import (
" flag"
" fmt"
" io"
" os"
" strings"
)
var (
n = flag.Bool(" n" , false, " omit trailing newline" )
s = flag.String(" s" , " " , " separator" )
)
var out io.Writer = os.Stdout // modified during testing
func main() {
flag.Parse()
if err := echo(!*n, *s, flag.Args()); err != nil {
fmt.Fprintf(os.Stderr, " echo: %v\n" , err)
os.Exit(1)
}
}
func echo(newline bool, sep string, args []string) error {
fmt.Fprint(out, strings.Join(args, sep))
if newline {
fmt.Fprintln(out)
}
return nil
}
< / code > < / pre >
< p > 在测试中我们可以用各种参数和标志调用echo函数， ， ， ： < / p >
< pre > < code class = "language-Go" > package main
import (
" bytes"
" fmt"
" testing"
)
func TestEcho(t *testing.T) {
var tests = []struct {
newline bool
sep string
args []string
want string
}{
{true, " " , []string{}, " \n" },
{false, " " , []string{}, " " },
{true, " \t" , []string{" one" , " two" , " three" }, " one\ttwo\tthree\n" },
{true, " ," , []string{" a" , " b" , " c" }, " a,b,c\n" },
{false, " :" , []string{" 1" , " 2" , " 3" }, " 1:2:3" },
}
for _, test := range tests {
descr := fmt.Sprintf(" echo(%v, %q, %q)" ,
test.newline, test.sep, test.args)
out = new(bytes.Buffer) // captured output
if err := echo(test.newline, test.sep, test.args); err != nil {
t.Errorf(" %s failed: %v" , descr, err)
continue
}
got := out.(*bytes.Buffer).String()
if got != test.want {
t.Errorf(" %s = %q, want %q" , descr, got, test.want)
}
}
}
< / code > < / pre >
< p > 要注意的是测试代码和产品代码在同一个包。虽然是main包， ， ， ， < / p >
< p > 通过将测试放到表格中，我们很容易添加新的测试用例。让我通过增加下面的测试用例来看看失败的情况是怎么样的：< / p >
< pre > < code class = "language-Go" > {true, " ," , []string{" a" , " b" , " c" }, " a b c\n" }, // NOTE: wrong expectation!
< / code > < / pre >
< p > < code > go test< / code > 输出如下：< / p >
< pre > < code > $ go test gopl.io/ch11/echo
--- FAIL: TestEcho (0.00s)
echo_test.go:31: echo(true, " ," , [" a" " b" " c" ]) = " a,b,c" , want " a b c\n"
FAIL
FAIL gopl.io/ch11/echo 0.006s
< / code > < / pre >
< p > 错误信息描述了尝试的操作（ ） ， ， < / p >
< p > 要注意的是在测试代码中并没有调用log.Fatal或os.Exit， ； ， ， ， （ ） ， < / p >
< h3 id = "1123-白盒测试" > < a class = "header" href = "#1123-白盒测试" > 11.2.3. 白盒测试< / a > < / h3 >
< p > 一种测试分类的方法是基于测试者是否需要了解被测试对象的内部工作原理。黑盒测试只需要测试包公开的文档和API行为， ， ， ， （ ， ） < / p >
< p > 黑盒和白盒这两种测试方法是互补的。黑盒测试一般更健壮， ， ， < / p >
< p > 我们已经看到两种测试的例子。TestIsPalindrome测试仅仅使用导出的IsPalindrome函数， ， ， ， < / p >
< p > 当我们准备TestEcho测试的时候， ， ， ， ， ， ， ， < / p >
< p > 下面的代码演示了为用户提供网络存储的web服务中的配额检测逻辑。当用户使用了超过90%的存储配额之后将发送提醒邮件。（ ： ， ， > 触发报警的逻辑，所以是很实用的案例。）< / p >
< p > < u > < i > gopl.io/ch11/storage1< / i > < / u > < / p >
< pre > < code class = "language-Go" > package storage
import (
" fmt"
" log"
" net/smtp"
)
func bytesInUse(username string) int64 { return 0 /* ... */ }
// Email sender configuration.
// NOTE: never put passwords in source code!
const sender = " notifications@example.com"
const password = " correcthorsebatterystaple"
const hostname = " smtp.example.com"
const template = `Warning: you are using %d bytes of storage,
%d%% of your quota.`
func CheckQuota(username string) {
used := bytesInUse(username)
const quota = 1000000000 // 1GB
percent := 100 * used / quota
if percent < 90 {
return // OK
}
msg := fmt.Sprintf(template, used, percent)
auth := smtp.PlainAuth(" " , sender, password, hostname)
err := smtp.SendMail(hostname+" :587" , auth, sender,
[]string{username}, []byte(msg))
if err != nil {
log.Printf(" smtp.SendMail(%s) failed: %s" , username, err)
}
}
< / code > < / pre >
< p > 我们想测试这段代码， < / p >
< p > < u > < i > gopl.io/ch11/storage2< / i > < / u > < / p >
< pre > < code class = "language-Go" > var notifyUser = func(username, msg string) {
auth := smtp.PlainAuth(" " , sender, password, hostname)
err := smtp.SendMail(hostname+" :587" , auth, sender,
[]string{username}, []byte(msg))
if err != nil {
log.Printf(" smtp.SendEmail(%s) failed: %s" , username, err)
}
}
func CheckQuota(username string) {
used := bytesInUse(username)
const quota = 1000000000 // 1GB
percent := 100 * used / quota
if percent < 90 {
return // OK
}
msg := fmt.Sprintf(template, used, percent)
notifyUser(username, msg)
}
< / code > < / pre >
< p > 现在我们可以在测试中用伪邮件发送函数替代真实的邮件发送函数。它只是简单记录要通知的用户和邮件的内容。< / p >
< pre > < code class = "language-Go" > package storage
import (
" strings"
" testing"
)
func TestCheckQuotaNotifiesUser(t *testing.T) {
var notifiedUser, notifiedMsg string
notifyUser = func(user, msg string) {
notifiedUser, notifiedMsg = user, msg
}
// ...simulate a 980MB-used condition...
const user = " joe@example.org"
CheckQuota(user)
if notifiedUser == " " & & notifiedMsg == " " {
t.Fatalf(" notifyUser not called" )
}
if notifiedUser != user {
t.Errorf(" wrong user (%s) notified, want %s" ,
notifiedUser, user)
}
const wantSubstring = " 98% of your quota"
if !strings.Contains(notifiedMsg, wantSubstring) {
t.Errorf(" unexpected notification message < < %s> > , " +
" want substring %q" , notifiedMsg, wantSubstring)
}
}
< / code > < / pre >
< p > 这里有一个问题： ， ， （ ） ， ， ， < / p >
< pre > < code class = "language-Go" > func TestCheckQuotaNotifiesUser(t *testing.T) {
// Save and restore original notifyUser.
saved := notifyUser
defer func() { notifyUser = saved }()
// Install the test's fake notifyUser.
var notifiedUser, notifiedMsg string
notifyUser = func(user, msg string) {
notifiedUser, notifiedMsg = user, msg
}
// ...rest of test...
}
< / code > < / pre >
< p > 这种处理模式可以用来暂时保存和恢复所有的全局变量，包括命令行标志参数、调试选项和优化参数；安装和移除导致生产代码产生一些调试信息的钩子函数；还有有些诱导生产代码进入某些重要状态的改变，比如超时、错误，甚至是一些刻意制造的并发行为等因素。< / p >
< p > 以这种方式使用全局变量是安全的， < / p >
< h3 id = "1124-外部测试包" > < a class = "header" href = "#1124-外部测试包" > 11.2.4. 外部测试包< / a > < / h3 >
< p > 考虑下这两个包： ， ； ， ， ， ， < / p >
< p > < img src = "../images/ch11-01.png" alt = "" / > < / p >
< p > 这样的行为在net/url包的测试代码中会导致包的循环依赖， ， ， < / p >
< p > 不过我们可以通过外部测试包的方式解决循环依赖的问题， < code > _test< / code > 后缀告诉go test工具它应该建立一个额外的包来运行测试。我们将这个外部测试包的导入路径视作是net/url_test会更容易理解， < / p >
< p > 因为外部测试包是一个独立的包，所以能够导入那些< code > 依赖待测代码本身< / code > 的其他辅助包； ， ， < / p >
< p > < img src = "../images/ch11-02.png" alt = "" / > < / p >
< p > 通过避免循环的导入依赖，外部测试包可以更灵活地编写测试，特别是集成测试（需要测试多个组件之间的交互），可以像普通应用程序那样自由地导入其他包。< / p >
< p > 我们可以用go list命令查看包对应目录中哪些Go源文件是产品代码， ， ： ； < / p >
< pre > < code > $ go list -f={{.GoFiles}} fmt
[doc.go format.go print.go scan.go]
< / code > < / pre >
< p > TestGoFiles表示的是fmt包内部测试代码， ， ： < / p >
< pre > < code > $ go list -f={{.TestGoFiles}} fmt
[export_test.go]
< / code > < / pre >
< p > 包的测试代码通常都在这些文件中， ； < / p >
< p > XTestGoFiles表示的是属于外部测试包的测试代码， ， ， ： < / p >
< pre > < code > $ go list -f={{.XTestGoFiles}} fmt
[fmt_test.go scan_test.go stringer_test.go]
< / code > < / pre >
< p > 有时候外部测试包也需要访问被测试包内部的代码， ， ： ， < / p >
< p > 例如， ， ； < / p >
< p > 为了确保fmt.isSpace和unicode.IsSpace函数的行为保持一致， ， ， < / p >
< pre > < code class = "language-Go" > package fmt
var IsSpace = isSpace
< / code > < / pre >
< p > 这个测试文件并没有定义测试代码； ， < / p >
< h3 id = "1125-编写有效的测试" > < a class = "header" href = "#1125-编写有效的测试" > 11.2.5. 编写有效的测试< / a > < / h3 >
< p > 许多Go语言新人会惊异于Go语言极简的测试框架。很多其它语言的测试框架都提供了识别测试函数的机制（ ） ， ， （ ） ， ， ， ， ， < / p >
< p > Go语言的测试风格则形成鲜明对比。它期望测试者自己完成大部分的工作， ， ； ， ， ， ， ， ， < / p >
< p > 下面的断言函数比较两个值，然后生成一个通用的错误信息，并停止程序。它很好用也确实有效，但是当测试失败的时候，打印的错误信息却几乎是没有价值的。它并没有为快速解决问题提供一个很好的入口。< / p >
< pre > < code class = "language-Go" > import (
" fmt"
" strings"
" testing"
)
// A poor assertion function.
func assertEqual(x, y int) {
if x != y {
panic(fmt.Sprintf(" %d != %d" , x, y))
}
}
func TestSplit(t *testing.T) {
words := strings.Split(" a:b:c" , " :" )
assertEqual(len(words), 3)
// ...
}
< / code > < / pre >
< p > 从这个意义上说，断言函数犯了过早抽象的错误：仅仅测试两个整数是否相同，而没能根据上下文提供更有意义的错误信息。我们可以根据具体的错误打印一个更有价值的错误信息，就像下面例子那样。只有在测试中出现重复模式时才采用抽象。< / p >
< pre > < code class = "language-Go" > func TestSplit(t *testing.T) {
s, sep := " a:b:c" , " :"
words := strings.Split(s, sep)
if got, want := len(words), 3; got != want {
t.Errorf(" Split(%q, %q) returned %d words, want %d" ,
s, sep, got, want)
}
// ...
}
< / code > < / pre >
< p > 现在的测试不仅报告了调用的具体函数、它的输入和结果的意义； ； ， ， < / p >
< p > 前面的例子并不需要额外的辅助函数， （ ） ， ， < / p >
< p > < strong > 练习11.5:< / strong > 用表格驱动的技术扩展TestSplit测试， < / p >
< h3 id = "1126-避免脆弱的测试" > < a class = "header" href = "#1126-避免脆弱的测试" > 11.2.6. 避免脆弱的测试< / a > < / h3 >
< p > 如果一个应用程序对于新出现的但有效的输入经常失败说明程序容易出bug（ ） ； ， ， ， ， < / p >
< p > 当一个测试函数会产生一个复杂的输出如一个很长的字符串、一个精心设计的数据结构或一个文件时，人们很容易想预先写下一系列固定的用于对比的标杆数据。但是随着项目的发展，有些输出可能会发生变化，尽管很可能是一个改进的实现导致的。而且不仅仅是输出部分，函数复杂的输入部分可能也跟着变化了，因此测试使用的输入也就不再有效了。< / p >
< p > 避免脆弱测试代码的方法是只检测你真正关心的属性。保持测试代码的简洁和内部结构的稳定。特别是对断言部分要有所选择。不要对字符串进行全字匹配，而是针对那些在项目的发展中是比较稳定不变的子串。很多时候值得花力气来编写一个从复杂输出中提取用于断言的必要信息的函数，虽然这可能会带来很多前期的工作，但是它可以帮助迅速及时修复因为项目演化而导致的不合逻辑的失败测试。< / p >
<!-- 公众号 -->
< hr >
< table >
< tr >
< td >
< img width = "222px" src = "https://chai2010.cn/advanced-go-programming-book/css.png" >
< / td >
< td >
< img width = "222px" src = "https://chai2010.cn/advanced-go-programming-book/cch.png" >
< / td >
< / tr >
< / table >
< div id = "giscus-container" > < / div >
< footer class = "page-footer" >
< span > © 2015-2016 | < a href = "https://github.com/gopl-zh" > Go语言圣经中文版< / a > , 仅学习交流使用< / span >
< / footer >
< / main >
< nav class = "nav-wrapper" aria-label = "Page navigation" >
<!-- Mobile navigation buttons -->
< a rel = "prev" href = "../ch11/ch11-01.html" class = "mobile-nav-chapters previous" title = "Previous chapter" aria-label = "Previous chapter" aria-keyshortcuts = "Left" >
< i class = "fa fa-angle-left" > < / i >
< / a >
< a rel = "next" href = "../ch11/ch11-03.html" class = "mobile-nav-chapters next" title = "Next chapter" aria-label = "Next chapter" aria-keyshortcuts = "Right" >
< i class = "fa fa-angle-right" > < / i >
< / a >
< div style = "clear: both" > < / div >
< / nav >
< / div >
< / div >
< nav class = "nav-wide-wrapper" aria-label = "Page navigation" >
< a rel = "prev" href = "../ch11/ch11-01.html" class = "nav-chapters previous" title = "Previous chapter" aria-label = "Previous chapter" aria-keyshortcuts = "Left" >
< i class = "fa fa-angle-left" > < / i >
< / a >
< a rel = "next" href = "../ch11/ch11-03.html" class = "nav-chapters next" title = "Next chapter" aria-label = "Next chapter" aria-keyshortcuts = "Right" >
< i class = "fa fa-angle-right" > < / i >
< / a >
< / nav >
< / div >
< script type = "text/javascript" >
window.playground_copyable = true;
< / script >
< script src = "../elasticlunr.min.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "../mark.min.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "../searcher.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "../clipboard.min.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "../highlight.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "../book.js" type = "text/javascript" charset = "utf-8" > < / script >
< script type = "text/javascript" charset = "utf-8" >
var pagePath = "ch11/ch11-02.md"
< / script >
<!-- Custom JS scripts -->
< script type = "text/javascript" src = "../js/custom.js" > < / script >
< script type = "text/javascript" src = "../js/bigPicture.js" > < / script >
< / body >
< / html >
