go語言測驗之TDD

一、TDD理解

TDD定義

TDD是測驗驅動開發（Test-Driven Development）的英文簡稱，是敏捷開發中的一項核心實踐和技術，也是一種設計方法論，TDD的原理是在開發功能代碼之前，先撰寫單元測驗用例代碼，測驗代碼確定需要撰寫什么產品代碼，TDD雖是敏捷方法的核心實踐，但不只適用于XP（Extreme Programming），同樣可以適用于其他開發方法和程序，
TDD的基本思路就是通過測驗來推動整個開發的進行，但測驗驅動開發并不只是單純的測驗作業，而是把需求分析，設計，質量控制量化的程序，其基本流程圖如下：

基于TDD周期具體完成“迭代”章節教程

1、撰寫測驗
在測驗中我們測驗Repeat函式，希望通過Repeat函式，回傳一個字串，該字串包含5個傳入的字符引數，
在iteration/repeat_test.go檔案下撰寫測驗代碼如下：

package iteration

import "testing"

func TestRepeat(t *testing.T) {
    repeated := Repeat("a")
    expected := "aaaaa"

    if repeated != expected {
        t.Errorf("expected '%q' but got '%q'", expected, repeated)
    }
}

2、運行測驗得到失敗的結果
由于沒有定義Repeat函式，此時運行測驗會報錯，運行測驗結果如下：

3、撰寫可以編譯的實作
嚴格遵守TDD方法的步驟與原則，現在只需讓代碼可編譯，這樣你就可以檢查測驗用例能否通過，
在iteration/repeat.go檔案下撰寫代碼如下：

package iteration

func Repeat(character string) string {
    return ""
}

4、運行測驗得到失敗的結果
在此已經定義了Repeat函式，接下來就可以進一步執行測驗代碼里面的具體內容，但是運行測驗的結果也會錯誤，這是因為Repeat函式定義的問題，運行測驗結果如下：

5、撰寫可以通過測驗的實作
根據上一步的運行測驗結果以及測驗代碼的要求，重新撰寫符合測驗要求的Repeat函式，由于已經知道了測驗代碼的具體內容，這一步可以通過需求寫出Repeat函式，
在iteration/repeat.go檔案下重新撰寫代碼如下：

package iteration

func Repeat(character string) string {
	var repeated string
	for i := 0; i < 5; i++ {
		repeated = repeated + character
	}
	return repeated
}

6、運行測驗得到成功的結果
對Repeat函式的重寫滿足了測驗代碼的需求，因此運行測驗會得到成功的結果，運行測驗結果如下：

7、重構
雖然代碼repeat.go檔案中的代碼已經通過了測驗，但是其代碼的規范性和簡潔性還是存在很多問題，所以需要我們對代碼進行重構，重構代碼要求在不改變代碼的邏輯和功能的前提下，盡可能的簡化代碼，簡化的目的有增強代碼的可讀性、加快代碼的執行速度等等，常見的簡化方法就是重用代碼（將頻繁使用的變數、常量以及函式另外定義出來，這樣就可以在各個地方呼叫此變數、常量、函式即可），在這里對repeat.go重構如下：

package iteration

const repeatCount = 5

func Repeat(character string) string {
	var repeated string
	for i := 0; i < repeatCount; i++ {
		repeated += character
	}
	return repeated
}

基準測驗（benchmarks）

基于TDD周期具體完成“迭代”章節的例子之后，還可以在此基礎上撰寫基準測驗，在 Go 中撰寫基準測驗（benchmarks）是該語言的另一個一級特性，它與在TDD中的撰寫測驗步驟非常相似，
在iteration/reoeat_test.go的原基礎上添加如下基準測驗的代碼：

func BenchmarkRepeat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Repeat("a")
    }
}

testing.B 可使你訪問隱性命名（cryptically named）b.N，基準測驗運行時，代碼會運行 b.N 次，并測量需要多長時間，代碼運行的次數不會對你產生影響，測驗框架會選擇一個它所認為的最佳值，以便讓你獲得更合理的結果，


用 go test -bench=. 來運行基準測驗，（如果在 Windows Powershell 環境下使用 go test -bench="."），運行測驗結果如下：

二、完成該教程“迭代”章節的練習

修改測驗代碼，以便呼叫者可以指定字符重復的次數，然后修復代碼

這里要求Repeat函式可以通過傳入一個引數來指定字符重復的次數，我們修改測驗代碼如下：

package iteration

import "testing"

func TestRepeat(t *testing.T) {
	repeated := Repeat("a", 6)
	expected := "aaaaaa"

	if repeated != expected {
		t.Errorf("expected %q but got %q", expected, repeated)
	}
}

由于Repeat函式的引數發生改變，運行測驗會得到失敗的結果，測驗結果如下：

修改主代碼使得測驗通過，代碼修改如下：

package iteration

//Repeat a string with 
func Repeat(character string, Readcount int) string {
	var repeated string
	for i := 0; i < Readcount; i++ {
		repeated += character
	}
	return repeated
}

此時運行測驗會得到成功的結果，運行測驗如下：

寫一個 ExampleRepeat 來完善你的函式檔案

為了完善函式檔案，我們還需要寫一個示例測驗，在repeat_test.go檔案里面加入一個示例測驗函式ExampleRepeat，該函式代碼如下：

func ExampleRepeat() {
	str := Repeat("b", 10)
	fmt.Println(str)
	//Output: bbbbbbbbbb
}

運行測驗結果如下：

這表明測驗函式和示例測驗函式都執行成功，此時查看函式檔案，發現該函式檔案已經包含示例測驗部分，

看一下 strings 包，找到你認為可能有用的函式，并對它們撰寫一些測驗

查看strings包檔案，部分函式如下：

對Compare、ToLower函式進行撰寫應用測驗，測驗代碼可簡單寫成如下：

package main

import (
	"fmt"
	"strings"
)

func main() {

	fmt.Println("compare:", strings.Compare("a", "b")) //Output: -1

	fmt.Println("tolower:", strings.ToLower("ABC")) // Output: abc
}

運行測驗代碼得到的結果如下：

三、TDD應用：go語言實作冒泡排序演算法

基于TDD周期完成冒泡排序演算法

1、撰寫測驗
在BubbleSort/BubbleSort_test.go檔案下撰寫測驗代碼如下：

package BubbleSort

import (
	"testing"
)

func TestBubbleSort(t *testing.T) {
	arr := [10]int{7, 6, 3, 9, 5, 0, 1, 4, 2, 8}
	sorted := BubbleSort(arr)
	expected := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

	for i := 0; i < 10; i++ {
		if sorted[i] != expected[i] {
			t.Errorf("expected %v but got %v", expected, sorted)
		}
	}
}

2、運行測驗得到失敗的結果
由于沒有定義BubbleSortt函式，此時運行測驗會報錯，運行測驗結果如下：

3、撰寫可以編譯的實作
嚴格遵守TDD方法的步驟與原則，現在只需讓代碼可編譯，這樣你就可以檢查測驗用例能否通過，
在BubbleSort/BubbleSort.go檔案下撰寫代碼如下：

package BubbleSort

func BubbleSort(arr [10]int) [10]int {
	return arr
}

4、運行測驗得到失敗的結果
在此已經定義了BubbleSort函式，接下來就可以進一步執行測驗代碼里面的具體內容，但是運行測驗的結果也會錯誤，這是因為BubbleSortt函式定義的問題，運行測驗結果如下：

5、撰寫可以通過測驗的實作
根據上一步的運行測驗結果以及測驗代碼的要求，重新撰寫符合測驗要求的BubbleSort函式，由于已經知道了測驗代碼的具體內容，這一步可以通過需求寫出BubbleSort函式，
在BubbleSort/BubbleSort.go檔案下重新撰寫代碼如下：

package BubbleSort

//BubbleSort sort a array
func BubbleSort(arr [10]int) [10]int {
	for i := 0; i < 9; i++ {
		for j := 0; j < 9-i; j++ {
			if arr[j] > arr[j+1] {
				temp := arr[j]
				arr[j] = arr[j+1]
				arr[j+1] = temp
			}
		}
	}
	return arr
}

6、運行測驗得到成功的結果
對BubbleSort函式的重寫滿足了測驗代碼的需求，因此運行測驗會得到成功的結果，運行測驗結果如下：

7、重構
根據前面提到的方法，對BubbleSort.go重構如下：

package BubbleSort

const count = 10

//BubbleSort sort a array
func BubbleSort(arr [10]int) [10]int {
	for i := 0; i < count-1; i++ {
		for j := 0; j < count-1-i; j++ {
			if arr[j] > arr[j+1] {
				temp := arr[j]
				arr[j] = arr[j+1]
				arr[j+1] = temp
			}
		}
	}
	return arr
}

基準測驗（benchmarks）

在BubbleSort/BubbleSort.go的原基礎上添加如下基準測驗的代碼：

func BenchmarkBubbleSort(b *testing.B) {
	for i := 0; i < b.N; i++ {
		arr := [10]int{7, 6, 3, 9, 5, 0, 1, 4, 2, 8}
		BubbleSort(arr)
	}
}

用 go test -bench=. 來運行基準測驗，（如果在 Windows Powershell 環境下使用 go test -bench="."），運行測驗結果如下：