Golang单元测试与断言编写流程详解

package main
func Sum(x int, y int) int {
    return x + y
}
func main() {
    Sum(5, 5)
}

package main
import "testing"
func TestSum(t *testing.T) {
    total := Sum(5, 5)
    if total != 10 {
       t.Errorf("Sum was incorrect, got: %d, want: %d.", total, 10)
    }
}

func TestSum(t *testing.T) {
	tables := []struct {
		x int
		y int
		n int
	}{
		{1, 1, 2},
		{1, 2, 3},
		{2, 2, 4},
		{5, 2, 7},
	}
	for _, table := range tables {
		total := Sum(table.x, table.y)
		if total != table.n {
			t.Errorf("Sum of (%d+%d) was incorrect, got: %d, want: %d.", table.x, table.y, total, table.n)
		}
	}
}

func IsPalindrome(s string) bool {
	for i := range s {
		if s[i] != s[len(s)-1-i] {
			return false
		}
	}
	return true
}

func TestPalindrome(t *testing.T) {
	if !IsPalindrome("detartrated") {
		t.Error(`IsPalindrome("detartrated") = false`)
	}
	if !IsPalindrome("kayak") {
		t.Error(`IsPalindrome("kayak") = false`)
	}
}
func TestNonPalindrome(t *testing.T) {
	if IsPalindrome("palindrome") {
		t.Error(`IsPalindrome("palindrome") = true`)
	}
}

func BenchmarkIsPalindrome(b *testing.B) {
	for i := 0; i < b.N; i++ {
		IsPalindrome("A man, a plan, a canal: Panama")
	}
}

func sortAndTotal(vals []int) (sorted []int, total int) {
	sorted = make([]int, len(vals))
	copy(sorted, vals)
	sort.Ints(sorted)
	for _, val := range sorted {
		total += val
		total++
	}
	return
}

func BenchmarkSort(b *testing.B) {
	rand.Seed(time.Now().UnixNano())
	size := 250
	data := make([]int, size)
	for i := 0; i < b.N; i++ {
		for j := 0; j < size; j++ {
			data[j] = rand.Int()
		}
		sortAndTotal(data)
	}
}

func BenchmarkSort(b *testing.B) {
	rand.Seed(time.Now().UnixNano())
	size := 250
	data := make([]int, size)
    // 开始前先重置
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
        // 准备数据时停止计时
		b.StopTimer()
		for j := 0; j < size; j++ {
			data[j] = rand.Int()
		}
        // 调用函数时启动计时
		b.StartTimer()
		sortAndTotal(data)
	}
}

import (
  "testing"
  "github.com/stretchr/testify/assert"
)
func TestSomething(t *testing.T) {
  var a string = "Hello"
  var b string = "Hello"
  assert.Equal(t, a, b, "The two words should be the same.")
}

func TestEqual(t *testing.T) {
  assertions := assert.New(t)
  assertion.Equal(a, b, "")
  // ...
}

// TestingT is an interface wrapper around *testing.T
type TestingT interface {
	Errorf(format string, args ...interface{})
}

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

import (
	"github.com/stretchr/testify/assert"
	"testing"
)
// 定义比较函数类型，方便后面批量准备测试数据
type ComparisonAssertionFunc func(assert.TestingT, interface{}, interface{}, ...interface{}) bool
// 测试参数类型
type args struct {
	x int
	y int
}
func TestAddition(t *testing.T) {
	tests := []struct {
		name      string
		args      args
		expect    int
		assertion ComparisonAssertionFunc
	}{
		{"2+2=4", args{2, 2}, 4, assert.Equal},
		{"2+2!=5", args{2, 2}, 5, assert.NotEqual},
		{"2+3==5", args{2, 3}, 5, assert.Exactly},
	}
	for _, tt := range tests {
        // 动态执行断言函数
		t.Run(tt.name, func(t *testing.T) {
			tt.assertion(t, tt.expect, Addition(tt.args.x, tt.args.y))
		})
	}
	assert.Equal(t, 2, Addition(1, 1), "sum result is equal")
}