## 一个例子

```sh
example/
   |--calc.go
   |--calc_test.go
```

```go
// calc.go
package main

func Add(a int, b int) int {
    return a + b
}

func Mul(a int, b int) int {
    return a * b
}
```

```go
// calc_test.go
package main

import "testing"

func TestAdd(t *testing.T) {
	if ans := Add(1, 2); ans != 3 {
		t.Errorf("1 + 2 expected be 3, but %d got", ans)
	}

	if ans := Add(-10, -20); ans != -30 {
		t.Errorf("-10 + -20 expected be -30, but %d got", ans)
	}
}
```

```sh
# 执行所有测试用例
$ go test -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
=== RUN   TestMul
--- PASS: TestMul (0.00s)
PASS
ok      example 0.007s

# 只想运行其中的一个用例
$ go test -run TestAdd -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
PASS
ok      example 0.007s
```

## 单元测试

运行 `go testing` 会扫描并编译运行工程目录下 `xxx_test.go` 代码文件中的 `TestXxx` 测试函数。

- 测试代码文件名 `xxx_test.go`，必须遵守。
- 测试函数签名 `TestXxx(t *testing.T)`，必须遵守。

```sh
# 当前目录（某目录）查找 xxx_test.go 测试代码
go test .
go test ./xxx/xxx

# 当前目录（某目录）以及子目录下所的 xxx_test.go 测试代码
go test ./...
go test ./xxx/xxx/...

# -v 参数，打开终端信息打印的开关。
# 测试代码中的打印函数（t.Log、t.Skip、t.Error、t.Fatal）
# fmt.Print 只会在任一测试函数为 FAIL 时，信息才会显示。
go test . -v

# -run 用来指定执行某个 TestXXX 单元测试函数，支持使用正则表达式来匹配测试函数名称。
# 像 TestMain、init() 这类框架性代码仍然会被执行，以确保环境正确。
go test -run ^TestXxx$
```

```go
// youwu_test.go
// 其实 t.Error 等同于 t.Log + t.Fail，当只标记错误不打印信息时，使用t.Fail。
// 打印的函数 `t.Log`、`t.Error`、`t.Fatal` 都有对应的格式化形式 `t.Logf`、`t.Errorf`、`t.Fatalf`
package main_test

import (
    "fmt"
    "testing"
)
func TestWorld(t *testing.T) {
    t.Log("TestWorlds")
}

// 初始化 init 方式
func init() {
    fmt.Println("hello, i'm \"init\".")
}

// 使用 t 实例的 Cleanup 方法注册一个在单元测试程序退出前执行的函数。
// 包级别：使用 TestMain 模式。
func cleanuptest() {
    fmt.Println("Cleanup.😀")
}
func TestClean(t *testing.T) {
    t.Cleanup(cleanuptest)
    t.Log("testing done.")
}
```

```sh
...
=== RUN   TestReportError
    youwu_test.go:42: report in: t.Error
--- FAIL: TestReportError (0.00s)
...
exit status 1
FAIL    hellotest       0.498s
```

```go
// 跳出当前单元测试函数，状态为跳出（SKIP，不计为失败），执行下一个测试函数
t.SkipNow()

// .Log -> t.SkipNow 打印并跳出当前单元测试函数
t.Skip("信息")

// 标记当前单元测试函数状态为错误（FAILED），继续执行
t.Fail()

// 标记当前单元测试函数状态为错误（FAILED）并跳出，执行下一个测试函数
t.FailNow()

// t.Log(信息) -> t.Fail()，该单元测试会继续执行
t.Error("信息")

// t.Log(信息) -> t.FailNow()，跳出该单元测试，执行下一个单元测试函数
t.Fatal("信息")
```

## 子测试

```go
// calc_test.go
// t.Error/t.Errorf 遇错不停，还会继续执行其他的测试用例
// t.Fatal/t.Fatalf 遇错即停
func TestMul(t *testing.T) {
	t.Run("pos", func(t *testing.T) {
		if Mul(2, 3) != 6 {
			t.Fatal("fail")
		}

	})
	t.Run("neg", func(t *testing.T) {
		if Mul(2, -3) != -6 {
			t.Fatal("fail")
		}
	})
}
```

对于多个子测试的场景，更推荐如下的写法(table-driven tests)：
如果数据量较大，或是一些二进制数据，推荐使用相对路径从文件中读取。

```go
//  calc_test.go
func TestMul(t *testing.T) {
	cases := []struct {
		Name           string
		A, B, Expected int
	}{
		{"pos", 2, 3, 6},
		{"neg", 2, -3, -6},
		{"zero", 2, 0, 0},
	}

	for _, c := range cases {
		t.Run(c.Name, func(t *testing.T) {
			if ans := Mul(c.A, c.B); ans != c.Expected {
				t.Fatalf("%d * %d expected %d, but %d got",
					c.A, c.B, c.Expected, ans)
			}
		})
	}
}
```

## 帮助函数

Go 语言在 1.9 版本中引入了 `t.Helper()`，用于标注该函数是帮助函数，
报错时将输出帮助函数调用者的信息，而不是帮助函数的内部信息。

关于 helper 函数的 2 个建议：

- 不要返回错误， 帮助函数内部直接使用 t.Error 或 t.Fatal 即可，
- 调用 t.Helper() 让报错信息更准确，有助于定位。

```go
// calc_test.go
package main

import "testing"

type calcCase struct{ A, B, Expected int }

func createMulTestCase(t *testing.T, c *calcCase) {
	t.Helper()
	if ans := Mul(c.A, c.B); ans != c.Expected {
		t.Fatalf("%d * %d expected %d, but %d got",
			c.A, c.B, c.Expected, ans)
	}

}

func TestMul(t *testing.T) {
	createMulTestCase(t, &calcCase{2, 3, 6})
	createMulTestCase(t, &calcCase{2, -3, -6})
	createMulTestCase(t, &calcCase{2, 0, 1}) // wrong case
}
```

## TestMain 方式

`TestMain` 是 `go testing` 测试框架的指定函数。
用于控制整个测试过程，这个函数是包级别的。
即一个包下，如果有多个 `xxx_test.go` 测试代码，只能在其中某个 `xxx_test.go` 中定义。

```go
// youwu_test.go
package main_test

import (
    "fmt"
    "os"
    "testing"
)

func TestHello(t *testing.T) {
    t.Log("TestHello")
}

// func TestWorld(t *testing.T) {
//  t.Log("TestWorlds")
// }

func cleanuptest() {
    fmt.Println("Cleanup.😀")
}
func TestClean(t *testing.T) {
    t.Cleanup(cleanuptest)
    t.Log("testing done.")
}

func init() {
    fmt.Println("hello, i'm \"init\".")
}

func TestMain(m *testing.M) {
    // 在开始运行单元测试代码之前
    // 可以在此处添加环境初始化相关代码或者函数调用
    fmt.Println("😀 开始所有测试前")

    retCode := m.Run()

    // 在全部测试代码运行结束退出之前
    // 可以在此处添加清理代码或函数调用
    fmt.Println("😀 结束所有测试前")

    os.Exit(retCode)
}
```

```sh
~/Projects/go/examples/hellotest
➜  go test -v
hello, i'm "init".
😀 开始所有测试前
=== RUN   TestHello
    youwu_test.go:10: TestHello
--- PASS: TestHello (0.00s)
=== RUN   TestClean
    youwu_test.go:22: testing done.
Cleanup.😀
--- PASS: TestClean (0.00s)
PASS
😀 结束所有测试前
ok      hellotest       0.369s
```

## benckmark 性能基准测试

多次运行，并计算其平均执行时间从而评估其运行效率。
go 性能基准测试代码的函数命名：

- `func BenchmarkXxx(*testing.T)`

基准测试报告每一列值对应的含义如下：

```go
type BenchmarkResult struct {
    N         int           // 迭代次数
    T         time.Duration // 基准测试花费的时间
    Bytes     int64         // 一次迭代处理的字节数
    MemAllocs uint64        // 总的分配内存的次数
    MemBytes  uint64        // 总的分配内存的字节数
}
```

```go
// youwu_test.go
package main_test

import (
    "fmt"
    "math/rand"
    "os"
    "testing"
)

func TestHello(t *testing.T) {
    t.Log("TestHello")
}

func init() {
    fmt.Println("hello, i'm \"init\".")
}

func TestMain(m *testing.M) {
    // 在开始运行单元测试代码之前
    // 可以在此处添加环境初始化相关代码或者函数调用
    fmt.Println("😀 开始所有测试前")

    retCode := m.Run()

    // 在全部测试代码运行结束退出之前
    // 可以在此处添加清理代码或函数调用
    fmt.Println("😀 结束所有测试前")

    os.Exit(retCode)
}

func BenchmarkRandInt(b *testing.B) {
    for i := 0; i < b.N; i++ {
        rand.Int()
    }
}
```

```sh
~/Projects/go/examples/hellotest
➜  go test -bench='Rand' -v .
hello, i'm "init".
😀 开始所有测试前
=== RUN   TestHello
    youwu_test.go:19: TestHello
--- PASS: TestHello (0.00s)
goos: darwin
goarch: amd64
pkg: hellotest
cpu: Intel(R) Core(TM) i5-7500 CPU @ 3.40GHz
BenchmarkRandInt
BenchmarkRandInt-4      70186930                16.21 ns/op
PASS
😀 结束所有测试前
ok      hellotest       1.476s
```

可以使用 b.ResetTimer() 先重置定时器

```go
func BenchmarkHello(b *testing.B) {
    ... // 耗时操作
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        fmt.Sprintf("hello")
    }
}
```

使用 RunParallel 测试并发性能

```go
func BenchmarkParallel(b *testing.B) {
	templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))
	b.RunParallel(func(pb *testing.PB) {
		var buf bytes.Buffer
		for pb.Next() {
			// 所有 goroutine 一起，循环一共执行 b.N 次
			buf.Reset()
			templ.Execute(&buf, "World")
		}
	})
}
```


go.md

## 测试函数（测试用例）

```rust
pub fn greeting(name: &str) -> String {
    format!("Hello {}!", name)
}

pub struct Guess {
    value: i32,
}

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 || value > 100 {
            panic!("Guess value must be between 1 and 100, got {}.", value);
        }

        Guess { value }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // 基本测试
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }

    // 测试失败
    #[test]
    fn another() {
        panic!("Make this test fail");
    }

    // 自定义错误信息
    // 任何在 assert! 的一个必需参数和 assert_eq! 和 assert_ne!
    // 的两个必需参数之后指定的参数都会传递给 format! 宏
    #[test]
    fn greeting_contains_name() {
        let result = greeting("Sunface");
        let target = "孙飞";
        assert!(
            result.contains(target),
            "你的问候中并没有包含目标姓名 {} ，你的问候是 {}",
            target,
            result
        );
    }

    // 测试panic
    // 可以给 should_panic 属性增加一个可选的 expected 参数
    #[test]
    #[should_panic(expected = "Guess value must be less than or equal to 100")]
    fn greater_than_100() {
        Guess::new(200);
    }

    // 使用 Result<T, E>
    // 不同于调用 assert_eq! 宏
    // 测试通过时返回 Ok(())，在测试失败时返回带有 String 的 Err
    #[test]
    fn it_works() -> Result<(), String> {
        if 2 + 2 == 4 {
            Ok(())
        } else {
            Err(String::from("two plus two does not equal four"))
        }
    }

    // 忽略测试
    #[test]
    #[ignore]
    fn expensive_test() {
        // 这里的代码需要几十秒甚至几分钟才能完成
    }
}
```

```rust
// assert_eq! 和 assert_ne!。这两个宏分别比较两个值是相等还是不相等。
// assert_eq! 和 assert_ne! 宏在底层分别使用了 == 和 !=。
// 当断言失败时，这些宏会使用调试格式打印出其参数，
// 这意味着被比较的值必需实现了 PartialEq 和 Debug trait
pub fn add_two(a: i32) -> i32 {
    a + 2
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn it_adds_two() {
        assert_eq!(4, add_two(2));
    }
    #[test]
    fn it_adds_tree() {
        assert_ne!(4, add_two(3));
    }
}
```

```sh
cargo test

# 使用 -- 分割命令行参数
# 第一种是提供给 cargo test 命令本身的，这些参数在 -- 之前指定
# 第二种是提供给编译后的可执行文件的，在 -- 之后指定
cargo test --help
cargo test -- --help

# 显示测试函数中的 println!
cargo test -- --show-output

# 运行单个测试
cargo test one_hundred

# 通过名称来过滤测试（名称中带add）
cargo test add

# 运行被忽略的测试函数
cargo test -- --ignored
# 运行名称中带 run 且被忽略的测试函数
cargo test run -- --ignored

# 测试通过是打印内容会被截获忽略，失败才显示。
# 截获输出的行为可以通过 --nocapture 参数来禁用
cargo test -- --nocapture
```

## 单元测试、集成测试

单元测试（unit tests）与 集成测试（integration tests）。

- 单元测试倾向于更小而更集中，在隔离的环境中一次测试一个模块，或者是测试私有接口。
  - 单元测试是跟正常的逻辑代码在同一个文件，因此必须对其进行特殊的标注，以便 Rust 可以识别。
  - 规范是在每个文件中创建包含测试函数的 `tests` 模块，并使用 `cfg(test)` 标注模块
- 而集成测试对于你的库来说则完全是外部的。
  - 集成测试的目的是测试库的多个部分能否一起正常工作。
  - 它们与其他外部代码一样，通过相同的方式使用你的代码，只测试公有接口而且每个测试都有可能会测试多个模块。
    - 集成测试被放入单独的目录文件中
    - 不需要创建测试模块及标注 `#[cfg(test)]`
    - 只能调用通过 pub 定义的 API
    - 一个标准的 Rust 项目，在它的根目录下会有一个 `tests` 目录，与 `src` 同级。
    - 在集成测试的 tests 目录下，每一个文件都是一个独立的包

Rust 只支持对 lib 类型的包进行集成测试，对于二进制包例如 `src/main.rs` 是无能为力的。
原因在于，我们无法在其它包中使用 use 引入二进制包，而只有 lib 类型的包才能被引入，例如 `src/lib.rs`

集成测试示例：

```rust
// tests/integration_test.rs
use adder;

mod common;

#[test]
fn it_adds_two() {
    common::setup();
    assert_eq!(4, adder::add_two(2));
}
```

```rust
// tests/common/mod.rs
// 希望这个函数能被多个测试文件的测试函数调用
pub fn setup() {
    // 编写特定库测试所需的代码
}
```

单元测试的共享模块路径

- `tests/common.rs`
- `tests/common/mod.rs`
  - 这样命名告诉 Rust 不要将 common 看作一个集成测试文件

```sh
# 运行某个特定集成测试文件中的所有测试
cargo test --test integration_test
```

## 测试才引入的包

`Cargo.toml`

```toml
# standard crate data is left out
[dev-dependencies]
pretty_assertions = "1"
```

```rust
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq; // 该包仅能用于测试

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
}
```

## 断言

- 所有模式下运行
  - `assert!`
  - `assert_eq!`
  - `assert_ne!`
- Debug 模式下运行
  - `debug_assert!`
  - `debug_assert_eq!`
  - `debug_assert_ne!`

## benckmark 基准测试

性能测试包含了两种：压力测试和基准测试

- 前者是针对接口 API，模拟大量用户去访问接口然后生成接口级别的性能数据；
- 而后者是针对代码，可以用来测试某一段代码的运行速度，例如一个排序算法。

官方提供的测试工具，目前最大的问题就是只能在非 stable 下使用，
原因是需要在代码中引入 test 特性: `#![feature(test)]`

需要先将当前仓库中的 Rust 版本从 stable 切换为 nightly:

- 安装 nightly 版本：\$ `rustup install nightly`
- 使用以下命令确认版本已经安装成功 `rustup toolchain list`
- 进入 adder 项目(之前为了学习测试专门创建的项目)的根目录，然后运行 `rustup override set nightly`，将该项目使用的 rust 设置为 nightly
  - 使用 `rustup override set stable` 切换回 stable 版本

```rust
// src/lib.rs
#![feature(test)]

extern crate test;

pub fn add_two(a: i32) -> i32 {
    a + 2
}

#[cfg(test)]
mod tests {
    use super::*;
    use test::Bencher;

    #[test]
    fn it_works() {
        assert_eq!(4, add_two(2));
    }

    #[bench]
    fn bench_add_two(b: &mut Bencher) {
        b.iter(|| add_two(2));
    }
}
```

```rust
#![feature(test)]

extern crate test;

fn fibonacci_u64(number: u64) -> u64 {
    let mut last: u64 = 1;
    let mut current: u64 = 0;
    let mut buffer: u64;
    let mut position: u64 = 1;

    return loop {
        if position == number {
            break current;
        }

        buffer = last;
        last = current;
        current = buffer + current;
        position += 1;
    };
}
#[cfg(test)]
mod tests {
    use super::*;
    use test::Bencher;

    #[test]
    fn it_works() {
       assert_eq!(fibonacci_u64(1), 0);
       assert_eq!(fibonacci_u64(2), 1);
       assert_eq!(fibonacci_u64(12), 89);
       assert_eq!(fibonacci_u64(30), 514229);
    }

    #[bench]
    fn bench_u64(b: &mut Bencher) {
        b.iter(|| {
            for i in 100..200 {
                // LLVM认为fibonacci_u64函数调用的结果没有使用，
                // 同时也认为该函数没有任何副作用(造成其它的影响，例如修改外部变量、访问网络等),
                // 因此它有理由把这个函数调用优化掉！
                // fibonacci_u64(i);
                test::black_box(fibonacci_u64(test::black_box(i)));
            }
        });
    }
}
```

```sh
cargo bench
```


自动化测试