（九）Go------捕获异常（defer,panic,revover）单元测试

一. Go 捕获异常

不同于其他语言

引入了defer、panic、recover

defer和recover捕获异常

1. Go程序抛出一个panic异常，在defer中通过recover捕获异常，然后处理

package main
import "fmt"
func test() {
    //在函数退出前，执行defer
    //捕捉异常后，程序不会异常退出
    defer func() {
        err := recover() //内置函数，可以捕捉到函数异常
        if err != nil {
            //这里是打印错误，还可以进行报警处理，例如微信，邮箱通知
            fmt.Println("err错误信息：", err)
        }
    }()
    //如果没有异常捕获，直接报错panic，运行时出错
    num1 := 10
    num2 := 0
    res := num1 / num2
    fmt.Println("res结果：", res)
}
func main() {
    test()
    fmt.Println("如果程序没退出，就走我这里")
}

二. Go 单元测试

1. 写些程序用来检测产品代码的结果和预期的一样
2. Go语言的测试依赖于go test测试命令和一组按约定方式编写的测试函数，测试命令可以运行这些测试函数。
3. Go单元测试对文件名和方法名有严格的要求。

文件名必须以xx_test.go命名

方法必须是Test[^a-z]开头

方法参数必须 t *testing.T

使用go test执行单元测试

go test 常见参数

包含单元测试和性能测试

通过go help test可以看到go test的使用说明：
格式形如：
go test [-c] [-i] [build flags] [packages] [flags for test binary]
参数解读：
-c : 编译go test成为可执行的二进制文件，但是不运行测试。
-i : 安装测试包依赖的package，但是不运行测试。
关于build flags，调用go help build，这些是编译运行过程中需要使用到的参数，一般设置为空
关于packages，调用go help packages，这些是关于包的管理，一般设置为空
关于flags for test binary，调用go help testflag，这些是go test过程中经常使用到的参数
-test.v : 是否输出全部的单元测试用例（不管成功或者失败），默认没有加上，所以只输出失败的单元测试用例。
-test.run pattern: 只跑哪些单元测试用例
-test.bench patten: 只跑那些性能测试用例
-test.benchmem : 是否在性能测试的时候输出内存情况
-test.benchtime t : 性能测试运行的时间，默认是1s
-test.cpuprofile cpu.out : 是否输出cpu性能分析文件
-test.memprofile mem.out : 是否输出内存性能分析文件
-test.blockprofile block.out : 是否输出内部goroutine阻塞的性能分析文件
-test.memprofilerate n : 内存性能分析的时候有一个分配了多少的时候才打点记录的问题。这个参数就是设置打点的内存分配间隔，也就是profile中一个sample代表的内存大小。默认是设置为512 * 1024的。如果你将它设置为1，则每分配一个内存块就会在profile中有个打点，那么生成的profile的sample就会非常多。如果你设置为0，那就是不做打点了。
你可以通过设置memprofilerate=1和GOGC=off来关闭内存回收，并且对每个内存块的分配进行观察。
-test.blockprofilerate n: 基本同上，控制的是goroutine阻塞时候打点的纳秒数。默认不设置就相当于-test.blockprofilerate=1，每一纳秒都打点记录一下
-test.parallel n : 性能测试的程序并行cpu数，默认等于GOMAXPROCS。
-test.timeout t : 如果测试用例运行时间超过t，则抛出panic
-test.cpu 1,2,4 : 程序运行在哪些CPU上面，使用二进制的1所在位代表，和nginx的nginx_worker_cpu_affinity是一个道理
-test.short : 将那些运行时间较长的测试用例运行时间缩短

目录结构

test
      |
       —— calc.go
      |
       —— calc_test.go

//calc.go
package main
func add(a, b int) int {
    return a + b
}
func sub(a, b int) int {
    return a - b
}

//calc_test.go
package main
import (
    "testing"
)
func TestAdd(t *testing.T) {
    r := add(2, 4)
    if r != 6 {
        t.Fatalf("add(2, 4) error, expect:%d, actual:%d", 6, r)
    }
    t.Logf("test add succ")
}

结果

cd test/
ls
calc.go        calc_test.go
//-v参数显示通过函数的信息
yugoMBP:test yuchao$ go test -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
        calc_test.go:11: test add succ...is ok
PASS
ok      gostudy/gobook/test     0.006s

单元测试文件代码规则

1.文件名必须是_test.go结尾的，这样在执行go test的时候才会执行到相应的代码

2.你必须import testing这个包

3.所有的测试用例函数必须是Test开头

4.测试用例会按照源代码中写的顺序依次执行

5.测试函数TestXxx()的参数是testing.T，我们可以使用该类型来记录错误或者是测试状态

6.测试格式：func TestXxx (t *testing.T),Xxx部分可以为任意的字母数字的组合，
但是首字母不能是小写字母[a-z]，例如Testintdiv是错误的函数名。

7.函数中通过调用testing.T的Error, Errorf, FailNow, Fatal, FatalIf方法，说明测试不通过，调用Log方法用来记录测试的信息。

练习

1. 数字阶乘

一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!。1808年，基斯顿·卡曼引进这个表示法。

package main

import "fmt"

func factorial(i int) int {
    if i <= 1 {
        return 1
    }
    return i * factorial(i-1)
}

func main() {
    var i int = 7
    fmt.Printf("Factorial of %d is %d\n", i, factorial(i))
}

//输出结果：
Factorial of 7 is 5040

2. 斐波那契数列(Fibonacci)

这个数列从第3项开始，每一项都等于前两项之和。

package main

import "fmt"

func fibonaci(i int) int {
    if i == 0 {
        return 0
    }
    if i == 1 {
        return 1
    }
    return fibonaci(i-1) + fibonaci(i-2)
}

func main() {
    var i int
    for i = 0; i < 10; i++ {
        fmt.Printf("%d\n", fibonaci(i))
    }
}
//输出结果：
    0
    1
    1
    2
    3
    5
    8
    13
    21
    34

三. Go defer 延迟

程序开发中经常要创建资源（数据库初始化连接，文件句柄，锁等），在程序执行完毕都必须得释放资源，Go提供了defer（延时机制）更方便、更及时的释放资源。

1. 内置关键字defer 用于延迟调用
2. defer在return前执行，常用于资源释放
3. 多个defer按 先进后出 的机制执行
4. defer语句的变量，在defer声明时定义
5. 显式 return 返回前，会先修改命名返回参数

defer用途：

1. 关闭文件句柄
2. 锁资源释放
3. 数据库连接释放

defer 是先进后出
后面的语句会依赖前面的资源，因此如果先前面的资源先释放了，后面的语句就没法执行了。

package main

import "fmt"

func main() {
    var whatever [5]struct{}

    for i := range whatever {
        defer fmt.Println(i)
    }
}
//结果
    4
    3
    2
    1
    0

package main
import (
    "fmt"
)
func testDefer1() {
    //defer机制 先入后出，如同羽毛球筒
    defer fmt.Println("hello v1") //顺序5
    defer fmt.Println("hello v2") //顺序4
    defer fmt.Println("hello v3") //顺序3
    fmt.Println("aaaaa")          // 顺序1
    fmt.Println("bbbb")           //顺序2
}
func testDefer2() {
    for i := 0; i < 5; i++ {
        //每次循环，defer将后入的语句压到defer栈
        //依旧先入后出
        defer fmt.Printf("i=%d\n", i)
    }
    fmt.Printf("running\n") //顺序1
    fmt.Printf("return\n")  //顺序2
}
func testDefer3() {
    var i int = 0
    //defer是声明时定义好的，之后再修改无效，因此i=0
    defer fmt.Printf("defer i=%d\n", i)
    i = 1000
    fmt.Printf("i=%d\n", i)
}
func main() {
    //testDefer1()
    //testDefer2()
    testDefer3()
}

1. 遇到了闭包

如果defer遇到了闭包

package main

import "fmt"

func main() {
    var whatever [3]struct{}
    for i := range whatever {
        defer func() { fmt.Println(i) }()
    }
}
//相当于
i结果最后为2，因为闭包原因，所以i最终为2
//结果，
2
2
2

package main

import "fmt"

type Test struct {
    name string
}

func (t *Test) Close() {
    fmt.Println(t.name, " closed")
}
func main() {
    ts := []Test{{"a"}, {"b"}, {"c"}}
    for _, t := range ts {
        defer t.Close()
    }
}
//预计的输出c b a,而是输出c c c
//结果
    c  closed
    c  closed
    c  closed

将defer t.Close()改为defer Close(t)
输出结果：
    c  closed
    b  closed
    a  closed

省去函数，可以用t.Close()

package main

import "fmt"

type Test struct {
    name string
}

func (t *Test) Close() {
    fmt.Println(t.name, " closed")
}
func main() {
    ts := []Test{{"a"}, {"b"}, {"c"}}
    for _, t := range ts {
        t2 := t
        defer t2.Close()
    }
}
    c  closed
    c  closed
    c  closed

结论：
defer后面的语句在执行的时候，函数调用的参数会被保存起来，但是不执行。也就是复制了一份。但是并没有说struct这里的this指针如何处理，通过这个例子可以看出go语言并没有把这个明确写出来的this指针当作参数来看待。

多个 defer 注册，按 FILO 次序执行 ( 先进后出 )。
异常也会输出

package main

func test(x int) {
    defer println("a")
    defer println("b")

    defer func() {
        println(100 / x) // div0 异常未被捕获，逐步往外传递，最后终止进程。
    }()

    defer println("c")
}

func main() {
    test(0)
}
//结果
	c
    b
    a
    panic: runtime error: integer divide by zero

*延迟调用参数在注册时求值或复制，可用指针或闭包 “延迟” 读取。

package main

func test() {
    x, y := 10, 20

    defer func(i int) {
        println("defer:", i, y) // y 闭包引用
    }(x) // x 被复制

    x += 10
    y += 100
    println("x =", x, "y =", y)
}

func main() {
    test()
}
输出结果:

    x = 20 y = 120
    defer: 10 120

*滥用 defer 可能会导致性能问题，例如：在一个 “大循环” 里。

package main

import (
    "fmt"
    "sync"
    "time"
)

var lock sync.Mutex

func test() {
    lock.Lock()
    lock.Unlock()
}

func testdefer() {
    lock.Lock()
    defer lock.Unlock()
}

func main() {
    func() {
        t1 := time.Now()

        for i := 0; i < 10000; i++ {
            test()
        }
        elapsed := time.Since(t1)
        fmt.Println("test elapsed: ", elapsed)
    }()
    func() {
        t1 := time.Now()

        for i := 0; i < 10000; i++ {
            testdefer()
        }
        elapsed := time.Since(t1)
        fmt.Println("testdefer elapsed: ", elapsed)
    }()

}
输出结果:

    test elapsed:  223.162µs
    testdefer elapsed:  781.304µs

2. defer陷阱

defer 与 closure

package main

import (
    "errors"
    "fmt"
)

func foo(a, b int) (i int, err error) {
    defer fmt.Printf("first defer err %v\n", err)
    defer func(err error) { fmt.Printf("second defer err %v\n", err) }(err)
    defer func() { fmt.Printf("third defer err %v\n", err) }()
    if b == 0 {
        err = errors.New("divided by zero!")
        return
    }

    i = a / b
    return
}

func main() {
    foo(2, 0)
}
输出结果：

    third defer err divided by zero!
    second defer err <nil>
    first defer err <nil>

解释：如果 defer 后面跟的不是一个 closure 最后执行的时候我们得到的并不是最新的值。

defer 与 return

package main

import "fmt"

func foo() (i int) {

    i = 0
    defer func() {
        fmt.Println(i)
    }()

    return 2
}

func main() {
    foo()
}
输出结果：

    2

解释：在有具名返回值的函数中（这里具名返回值为 i），执行 return 2 的时候实际上已经将 i 的值重新赋值为 2。所以defer closure 输出结果为 2 而不是 1。