Unidade de testar os efeitos: uma função ou uma confirmação resultado da introdução de pacote é correcta.
Método tradicional: se os resultados da saída de teste e resultados esperados são consistentes,
ter algo a ver com o ambiente de produção, para ser eficaz, não existe tal ambiente de teste ambiental;
não é propício para a gestão, a necessidade de estrutura de teste para resolver o problema.
Em golang com um teste leve framework de testes , comando de teste Go Test para implementar testes e desempenho da unidade de teste (código de execução leva tempo).
Resolver os seguintes problemas por testes de unidade:
- Certifique-se de que cada função é executado, e os resultados são enviados corretamente.
- Escrever código para garantir o desempenho é bom
- Um teste de unidade lógica pode descobrir erros, uso do design e implementação de exposição precoce programa para localizar a solução para o problema.
- teste de desempenho focada em uma série de questões sobre a programação, mas também permite que o programa permaneça estável a alta concorrência.
Uso teste de unidade
- Testados separadamente criar uma pasta, e main () executando teste de isolamento não requer a entrada main () arquivo.
- .Vá arquivo de teste de função, extraído _test.go arquivo, precisa importar pacote Testing _test.go.
exemplo:
package tst
import "testing"
func Test<dest>(t *testing.T) {
//引入测试函数1
//引入测试函数2
}
Caso Simulação: tst criar um pacote, e em seguida, escrever dois artigos, Accumu.go e Accumu_test.go dentro, dois documentos escritos da seguinte forma
Accumu.go
//>>> Accumu.go <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
package tst
func Accumu(n int) int { //就是一个累加器，没啥说得，没有main()
res := 0
for i := 0 ; i <= n ; i++ {
res += i
}
return res
}
Accumu_test.go
//>>> Accumu_test.go <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//测试单个文件：切换到此目录下，go test -v会默认测试所有函数，如果只想测试其中一个，需要命令 go test -v Accumu_test.go Accumu.go
//测试单个方法：切换到此目录下，需要命令 go test -v -test.run Accumu
package tst
import (
"testing" //需要导入testing包
)
func TestAccumu(t *testing.T) { //在Goland中，默认test文件都会直接出此类格式
res := Accumu(10) //测试结果与res所传函数有关，与函数名无关
if res != 55 {
t.Fatalf("应输入值为%v，实际输出为%v",55,res) //遇到错误即终止，并会反馈结果为FAIL
}
t.Logf("程序测试正确！") //如果测试无异常则打印PASS，后面日志为t.logf()中的字符串内容
} //关于测试结果，Goland中测试文件都会有一个红色箭头，因此无需黑屏终端go test命令来使用
Os resultados dos testes são os seguintes:
/*
e:\Golear\src\tst>go test -v
=== RUN TestAccumu
--- PASS: TestAccumu (0.00s)
cal_test.go:12: 程序测试正确！
PASS
ok _/e_/Golear/src/tst 0.536s
e:\Golear\src\tst>go test -v -test.run Accumu
=== RUN TestAccumu
--- PASS: TestAccumu (0.00s)
cal_test.go:12: 程序测试正确！
PASS
ok _/e_/Golear/src/tst 0.607s
*/
A serialização e deserializing testes unitários + + arquivo utilizado em conjunto com a aplicação real:
Demanda: Criação de uma estrutura: Heros
campos: cadeia de nome, int Age, Hobby corda
método: Loja () após a variável estrutura serializado salvos em um arquivo em kunkun.txt
RevStore () a partir da estrutura de arquivo Resumo variável kunkun.txt ler e deserialize
teste de unidade: os ensaios os dois métodos acima descritos é normal.
:( segmento de código núcleo assumir como produção, não pode ser facilmente testada)
package main
import (
"bufio"
"encoding/json"
"fmt"
"io/ioutil"
"os"
)
type KunFamily struct {
Name string `json:"name"`
Age int `json:"age"`
Hobby string `json:"hobby"`
}
func (k *KunFamily) Store() bool { //为了确保测试，故返回布尔值
slice, err := json.Marshal(k)
if err != nil {
fmt.Println("序列化失败，失败原因为： ",err)
return false
}
file, err := os.OpenFile("D:/kunkun.txt", os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fmt.Println("请检查错误为：", err)
return false
}
defer file.Close()
writer := bufio.NewWriter(file)
_, _ = writer.WriteString(string(slice))
_ = writer.Flush()
return true
}
func (k *KunFamily) RevStore() bool { //为了确保测试，故返回布尔值
//读取文件
file := "D:/kunkun.txt"
content, err := ioutil.ReadFile(file)
if err != nil {
fmt.Println("读取错误，错误为：", err)
return false
}
//反序列化
err1 := json.Unmarshal([]byte(content), k) //err := json.Unmarshal([]byte(string), &<struct结构体变量>)
if err1 != nil {
fmt.Println("反序列化出现异常，异常报错为：",err1)
return false
}
return true
}
func main() {
var caixukun1 = &KunFamily{"蔡徐坤1",20,"鸡你太美"}
caixukun1.Store()
caixukun1.RevStore()
}
arquivo de teste é baixado a partir da produção :( um segmento de código, x.go)
package tst
import (
"bufio"
"encoding/json"
"fmt"
"io/ioutil"
"os"
)
type KunFamily struct {
Name string `json:"name"`
Age int `json:"age"`
Hobby string `json:"hobby"`
}
func (k *KunFamily) Store() bool {
slice, err := json.Marshal(k)
if err != nil {
fmt.Println("序列化失败，失败原因为： ",err)
return false
}
file, err := os.OpenFile("D:/kunkun.txt", os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fmt.Println("请检查错误为：", err)
return false
}
defer file.Close()
writer := bufio.NewWriter(file)
_, _ = writer.WriteString(string(slice))
_ = writer.Flush()
return true
}
func (k *KunFamily) RevStore() bool {
file := "D:/kunkun.txt"
content, err := ioutil.ReadFile(file)
if err != nil {
fmt.Println("读取错误，错误为：", err)
return false
}
err1 := json.Unmarshal([]byte(content), k) //err := json.Unmarshal([]byte(string), &<struct结构体变量>)
if err1 != nil {
fmt.Println("反序列化出现异常，异常报错为：",err1)
return false
}
return true
}
arquivo de teste escrito: (x_test.go)
package tst
import (
"testing"
)
func TestKunFamily_Store(t *testing.T) {
var caixukun = &KunFamily{"蔡徐坤1",20,"鸡你太美"}
res := caixukun.Store()
if res != true {
t.Fatalf("测试失败")
}
t.Logf("程序测试正确！")
}
func TestKunFamily_RevStore(t *testing.T) {
var caixukun = &KunFamily{"蔡徐坤1",20,"鸡你太美"}
res := caixukun.RevStore()
if res != true {
t.Fatalf("测试失败")
}
t.Logf("程序测试正确！")
}
