共计 4276 个字符，预计需要花费 11 分钟才能阅读完成。
作业 2: TDD 实际报告
试验环境
操作系统：Mac OS
编译器：VScode
迭代章节练习
练习 1
- 批改测试代码，以便调用者能够指定字符反复的次数，而后修复代码
首先编写测试文件 repeat_test.go 代码和章节中给出的基本相同，只须要更改 Repeat() 函数中的参数为两个，一个是须要反复的字符串，另一个是反复的次数，代码如下
package iteration
import "testing"
func TestRepeat(t *testing.T) {repeated := Repeat("a", 4)
expected := "aaaaa"
if repeated != expected {t.Errorf("expected'%q'but got'%q'", expected, repeated)
}
}首先运行测试代码，失去如下的后果
能够看到因为未编写须要测试的函数，所以编译会失败
开始编写 Repeat() 函数，函数须要两个参数，一个是 string 类型，另一个是 int 类型，实现的办法也是用了 for 循环的模式，代码如下
package iteration
func Repeat(character string, count int) string {
var ret string = ""
for i := 0; i < count; i++ {ret += character}
return ret
}测试的代码写好后，能够间接在 VScode 中编译运行，或者在命令行中以 go test 命令进行测试，失去的后果如下所示
能够看到后果 FAIL，起因是因为我在测试文件中抉择了先测试 repeat 4 次，所以失去的后果与冀望的不一样，从新更改测试代码，便能够失去正确的后果，会显示 PASS 如下所示：
练习 2
- 写一个
ExampleRepeat来欠缺你的函数文档
对于示例的用法，在前一章节：整数中提到过，间接在 repeat_test.go 中创立新的函数 ExampleRepeat，此函数用于输入失去的后果 ( 留神：因为须要进行输入所以在代码开始处须要导入 fmt 包)，与前面的正文中的内容进行比拟，如果雷同则胜利，否则失败，代码如下：
func ExampleRepeat() {s := Repeat("a", 5)
fmt.Println(s)
// Output: aaaa
}能够看到我设置的迭代 5 次，而上面正文的输入是迭代了四次所以应该失去谬误的后果，如下所示：
从新批改上面的正文使其迭代五次，检测的后果如下所示：
由后果可知，测试胜利 PASS
练习 3
- 看一下 strings 包。找到你认为可能有用的函数，并对它们编写一些测试。投入工夫学习规范库会缓缓失去回报。
func Compare(a, b string) int函数，此函数是用来比拟前后字符串的字典序的大小，如果 a < b 则返回 -1；a = b 则返回 0；a > b 则返回 1，测试的代码文件为compare_test.go
package iteration
import (
"strings"
"testing"
)
func TestCompare(t *testing.T) {ans := strings.Compare("h", "z")
expected := -1
if ans != expected {t.Errorf("expected'%d'but got'%d'", expected, ans)
}
}而后进行测试，失去的后果如下所示：
由后果可知测试胜利
func Count(s, substr string) int函数，此函数是统计字符串 s 中蕴含子串 substr 的个数，而后返回该值，测试的代码文件为count_test.go
package iteration
import (
"strings"
"testing"
)
func TestCount(t *testing.T) {ans := strings.Count("cheeze", "e")
expected := 3
if ans != expected {t.Errorf("expected'%d'but got'%d'", expected, ans)
}
}而后进行测试，失去的后果如下所示：
由后果可知，测试胜利
func ReplaceAll(s, old, new string) string函数，此函数是在 s 字符串中用 new 字符串去代替所有呈现的 old 字符串，测试的文件为replace_test.go
package iteration
import (
"strings"
"testing"
)
func TestReplace(t *testing.T) {ans := strings.ReplaceAll("oink oink oink", "oink", "moo")
expected := "moo moo moo"
if ans != expected {t.Errorf("expected'%s'but got'%s'", expected, ans)
}
}而后进行测试，失去的后果如下所示：
由后果可知，测试胜利
快排算法实现
算法介绍
疾速排序（Quicksort）是对冒泡排序的一种改良。算法的次要步骤为：
- 首先设定一个分界值，通过该分界值将数组分成左右两局部。
- 将大于或等于分界值的数据集中到数组左边，小于分界值的数据集中到数组的右边。此时，右边局部中各元素都小于或等于分界值，而左边局部中各元素都大于或等于分界值。
- 而后，右边和左边的数据能够独立排序。对于左侧的数组数据，又能够取一个分界值，将该局部数据分成左右两局部，同样在右边搁置较小值，左边搁置较大值。右侧的数组数据也能够做相似解决。
- 反复上述过程，能够看出，这是一个递归定义。通过递归将左侧局部排好序后，再递归排好右侧局部的程序。当左、右两个局部各数据排序实现后，整个数组的排序也就实现了。
通过上述对于算法的形容，首先实现一个 main 函数，来测试一下疾速排序是否胜利实现，代码如下：
package main
import "fmt"
const MAXN = 10
var arr = []int{7, 4, 8, 5, 3, 6, 9, 1, 10, 2}
// 疾速排序递归实现
func QuickSort(arr []int, l, r int) {pivot := arr[l] // 选取两头值
pos := l // 两头值的地位
i, j := l, r
for i <= j {for j >= pos && arr[j] >= pivot {j--}
if j >= pos {arr[pos] = arr[j]
pos = j
}
for i <= pos && arr[i] <= pivot {i++}
if i <= pos {arr[pos] = arr[i]
pos = i
}
}
arr[pos] = pivot
if pos-l > 1 {QuickSort(arr, l, pos-1)
}
if r-pos > 1 {QuickSort(arr, pos+1, r)
}
}
func main() {QuickSort(arr, 0, len(arr)-1)
for i := 0; i < MAXN; i++ {fmt.Printf("%d\t", arr[i])
}
}通过运行整个代码，能够看到后果如下：
先写测试
首先写一个测试文件 QuickSort_test.go，但并不写 QuickSort.go文件，看看测试文件的输入
package Qsort
import "testing"
const MAXN = 10
var arr = []int{7, 4, 8, 5, 3, 6, 9, 1, 10, 2}
func TestQuickSort(t *testing.T) {QuickSort(arr, 0, MAXN-1)
expected := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
flag := true
for i := 0; i < MAXN; i++ {if arr[i] != expected[i] {flag = false}
}
if flag == false {t.Errorf("expected")
for i := 0; i < MAXN; i++ {t.Errorf("%d\t", expected[i])
}
t.Errorf("but got")
for i := 0; i < MAXN; i++ {t.Errorf("%d\t", arr[i])
}
}
}写好代码后，间接运行，失去以下的后果
能够看到因为短少被测试的文件，所以会编译出错
起码代码运行测试
开始写被测试的代码文件 QuickSort.go，使得测试可能胜利运行起来，所以间接写一个语法正确的空代码即可
package Qsort
// 疾速排序递归实现
func QuickSort(arr []int, l, r int) {}写好代码后，进行测试，失去的输入后果如下所示
代码补全胜利测试
后行测试完结后，将QuickSort.go 文件进行批改，批改后的代码为
package Qsort
// 疾速排序递归实现
func QuickSort(arr []int, l, r int) {pivot := arr[l] // 选取两头值
pos := l // 两头值的地位
i, j := l, r
for i <= j {for j >= pos && arr[j] >= pivot {j--}
if j >= pos {arr[pos] = arr[j]
pos = j
}
for i <= pos && arr[i] <= pivot {i++}
if i <= pos {arr[pos] = arr[i]
pos = i
}
}
arr[pos] = pivot
if pos-l > 1 {QuickSort(arr, l, pos-1)
}
if r-pos > 1 {QuickSort(arr, pos+1, r)
}
}首先进行测试，将测试的代码中 expected 中的 2 改为 3 看看测试文件是否能检测出错，失去的后果如图所示
由上图可知测试文件能检测进去谬误，而后进行正确的测试，失去的后果为
如上图所示，能够看到胜利测试了，并且通过了，阐明我设计的疾速排序代码是正确的。
重构
因为原算法并没有太多须要批改的中央，所以在原代码的上方进行了正文
基准测试
在测试文件中写基准测试，使测试代码运行 b.N 次，并测试须要多长的工夫，增加的代码如下所示
func BenchmarkQuickSort(b *testing.B) {
for i := 0; i < b.N; i++ {var arrt = []int{7, 4, 8, 5, 3, 6, 9, 1, 10, 2}
QuickSort(arrt, 0, MAXN-1)
}
}写好基准测试代码后，在命令行中输出命令 go test -bench=. 进行测试代码运行的工夫，后果是如下所示
至此实现了全副的测试过程
github 地址
代码传送门：传送门
总结
通过本次试验学会了测试的根本步骤，也了解 TDD、重构、测试、基准测试等概念，并且进一步把握了 GO 语言的一些用法啊，可能纯熟的使用到代码编写中，在代码的编写中也遇到了一些艰难，也是通过 C 语言学习网中对 GO 的学习才得以解决。