Go语言-单元测试

今天闲来无事看了下GO语言，首先是看了酷壳耗子大牛的文章，然后下载安装，配置环境等等，由于我下载的是安装版，所以环境变量什么的不用自己配置。然后又刚好去图书馆借了两本书：《Go语言编程》许式伟/吕桂华编著，《Go语言 云动力》樊虹编著，接着就开始看。。

好了，废话不多说，直接进入主题：

在《Go语言编程》我看到他有一些例子，在书的第二章最后，讲的是两种排序的Go语言实现（快速排序和冒泡排序）本文的源代码来自《Go语言编程》许式伟/吕桂华编著

排序本身不重要，因为之前用C，java也实现过，重要的是练练写Go语言，熟悉下语法。

环境：

我设置的GOPATH为：G:\go

然后所有文件及目录如下：

主程序（sorter.go）：G:\go\src

排序算法（bubblesort.go、qsort.go）：G:\go\src\mysort       （注意，这里不能取名为sort否则后面执行 go install的时候会出错）

测试类（bubblesort_test.go、qsort_test.go）：G:\src\sort_test （注意，测试类必须以_test.go结尾，之前在_test.go结尾的文件中编写了main函数，然后果断编译出错）

源代码：

soter.go

package main

import(
	"flag"
	"fmt"
	"bufio"
	"io"
	"os"
	"strconv"
	"time"
	"mysort"
)

var infile *string = flag.String("i","infile","File contains values for sorting")
var outfile *string = flag.String("o","outfile","File to receive sorted values")
var algorithm *string = flag.String("a","qsort","Sort algorithm")

func readValues(infile string)(values []int,err error){
	file,err := os.Open(infile)
	if err != nil{
		fmt.Println("Failed to open the input file",infile)
		return
	}
	
	defer file.Close()
	
	br := bufio.NewReader(file)
	
	values = make([]int,0)
	
	for{
		line,isPrefix,err1 := br.ReadLine()
		
		if err1 != nil{
			if err1 != io.EOF{
				err = err1
			}
			break
		}
		
		if isPrefix {
			fmt.Println("A too long line seems unexpected.")
			return
		}
		
		str := string(line)
		
		value,err1 := strconv.Atoi(str)
		
		if err1 != nil{
			err = err1
			return
		}
		
		values = append(values,value)
	}
	return
}

func writeValues(values []int,outfile string) error{
	file,err := os.Create(outfile)
	
	if err != nil{
		fmt.Println("Failed to create the output file ",outfile)
		return err
	}
	defer file.Close()
	for _,value := range values{
		str := strconv.Itoa(value)
		file.WriteString(str + "\n")
	}
	return nil
}

func main(){
	flag.Parse()
	if infile != nil{
		fmt.Println("infile = ",*infile,"outfile = ",*outfile,"algorithm = ",*algorithm)
	}
	
	values,err := readValues(*infile)
	if err == nil{
		t1 := time.Now()
		switch *algorithm{
			case "qsort":
				mysort.QuickSort(values)
			case "bubblesort":
				mysort.BubbleSort(values)
			default:
				fmt.Println("Sorting algorithm",*algorithm,"is either unknown or unsupported.")
		}
		t2 := time.Now()
		fmt.Println("The sorting process costs",t2.Sub(t1),"to complete")
		writeValues(values,*outfile)
	}else{
		fmt.Println(err)
	}
}

排序算法:

bubblesort.go

package mysort

func BubbleSort(values []int){
	flag := true
	
	for i:=0;i < len(values)-1;i++{
		flag = true
		
		for j:=0;j<len(values)-i-1;j++{
			if values[j] > values[j+1]{
				values[j],values[j + 1] = values[j + 1],values[j]
				flag = false
			}// end if
		}//end for j=...
		if flag == true{
			break
		}
	}// end for i=...
}

qsort.go

package mysort

func quickSort(values []int,left,right int){
	temp:=values[left]
	p := left
	i,j:=left,right
	
	for i <= j{
		for j>=p && values[j] >= temp{
			j--
		}
		if(j >= p){
			values[p] = values[j]
			p = j
		}
		if values[i] <= temp && i <= p{
			i++
		}
		if i<=p {
			values[p] = values[i]
			p = i
		}
	}
	
	values[p] = temp
	if p-left > 1{
		quickSort(values,left,p-1)
	}
	if right-p > 1{
		quickSort(values,p+1,right)
	}
}

func QuickSort(values []int){
	quickSort(values,0,len(values)-1)
}

测试类:

bubblesort_test.go

package sort_test

import (
	"mysort"
	"testing"
)

func TestBubbleSort1(t *testing.T){
	values := []int{5,4,3,2,1}
	mysort.BubbleSort(values)
	if values[0] != 1 || values[1] != 2 || values[2] != 3||
		values[3] != 4 || values[4] != 5{
			t.Error("BubbleSort() failed , Got",values,"Excepted 1 2 3 4 5")
		}
}

func TestBubbleSort2(t *testing.T){
	values := []int{5,5,3,2,1}
	mysort.BubbleSort(values)
	if values[0] != 1 || values[1] != 2 || values[2] != 3||
		values[3] != 5 || values[4] != 5{
			t.Error("BubbleSort() failed , Got",values,"Excepted 1 2 3 5 5")
		}
}

func TestBubbleSort3(t *testing.T){
	values := []int{5}
	mysort.BubbleSort(values)
	if values[0] != 5{
			t.Error("BubbleSort() failed , Got",values,"Excepted 5")
		}
}

qsort_test.go

package sort_test
import(
	"mysort"
	"testing"
)
func TestQuickSort1(t *testing.T){
	values:=[]int{5,4,3,2,1}
	mysort.QuickSort(values)
	if values[0] != 1 || values[1] != 2 || values[2] != 3||
		values[3] != 4 || values[4] != 5{
			t.Error("QuickSort() failed , Got",values,"Excepted 1 2 3 4 5")
		}
}

func TestQuickSort2(t *testing.T){
	values := []int{5,5,3,2,1}
	mysort.QuickSort(values)
	if values[0] != 1 || values[1] != 2 || values[2] != 3||
		values[3] != 5 || values[4] != 5{
			t.Error("QuickSort() failed , Got",values,"Excepted 1 2 3 5 5")
		}
}

func TestQuickSort3(t *testing.T){
	values := []int{5}
	mysort.QuickSort(values)
	if values[0] != 5{
			t.Error("QuickSort() failed , Got",values,"Excepted 5")
		}
}

运行：首先是测试(以快速排序为例)

进入到G:\go\src\sort_test 目录下

>cd /d G:\go\src\sort_test
>go install

>go build qsort_test.go

>go test qsort_test.go

如果代码和GOPATH设置没问题，那么就会显示OK

然后是运行主程序，在这之前，现在src目录下新建一个文件“unsorted.dat”，用记事本打开然后输入

123
3046
3
64
490
1
23
5331
2
7
4
2
132

保存，接下来：

进入：G:\go\src下

>cd G:\go\src

>go build

然后会在src目录下生成一个sorter.exe

命令行输入(G:\go\src下)：

sorter.exe -i unsorted.dat -o sorted.dat -a qsort（如果你是想运行冒泡排序这一行命令的最后一个单词改为:bubblesort）

如果代码和GOPATH配置没有问题，那么会在src目录下生成一个sorted.dat，用记事本打开可以发现一面的内容已经是排好序的

好，操作到此为止--------------------------------------------------------------------------------------------------------

---