Ite unitas testing

Ite unitas temptationis

2024-07-12

In lingua Ite, unitas probatio per sarcinam probativam in bibliotheca vexillum, quae copia functionum praebet scribendo, currendo et administrando unitatem simplicem et efficacem probat.

1. Rules

Test file nominatio praecepta
Documenta lima regulae in Go est addere_test.go .Exempli gratia, si acalculator.go lima, test lima correspondens sitcalculator_test.go。
Naming praecepta test munera
Munus test est incipereTest incipit, et potest sequi aliquod filum non inane, e.gTestAdd、TestSubtract manere.
usus testing.T Assertiones et error renuntiationes
Munus in test, uteretesting.T Typus ambitum administrare test status et output.vos can utort.Error*、t.Fail* et alii modi ad indicandum defectum experimentum et ad output pertinentes errorum notitias.

2. Test exemplum Unit

2.1 Una test causa

Munus calculatoris in sarcina calculatoris definitur, exsecutio specifica talis est:

package calculator

func Add(a, b int) int {
	return a + b
}
1
2
3
4
5

In directorio currenti creamus testam tabellam calculator_test.go et munus test definire ut sequitur:

package calculator

import "testing"


func TestAdd(t *testing.T) {
	result := Add(1, 2)
	expected := 3
	if result != expected {
		t.Errorf("Add(1,2) return %d, expected %d", result, expected)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

Ad hanc unitatem examinis currendam, utere iussione test.In linea praeceptiva, indicem in quo calculator.go et calculator_test.go continentur, ingredere, et deinde exercego test, hi eventus sic sunt

go test
PASS
ok      modu    0.226s
1
2
3

2.2 Multiplex test casus

Sequenti munus experimentum addere in calculator_test.go:

func TestAdd2(t *testing.T) {
	result := Add(3, 2)
	expected := 3
	if result != expected {
		t.Errorf("Add(1,2) return %d, expected %d", result, expected)
	}
}
1
2
3
4
5
6
7

Ut melius videremus exsecutionem uniuscuiusque casus in output eventus, possumusgo test -vparametri ut sit output completum experimentum consequitur.

go test -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
=== RUN   TestAdd2
    calculator_test.go:17: Add(1,2) return 5, expected 3
--- FAIL: TestAdd2 (0.00s)
FAIL
exit status 1
FAIL    modu    0.216s
1
2
3
4
5
6
7
8
9

2.3 det speciem currit test casibus

go test -run Praeceptum decurrere potest probat secundum praefinitum modum. Hoc mandatum sustinet expressiones regulares ad probationes eligendas functiones ad currendum.

Exempli causa, correcto TestAdd2 casu utimur, passgo tes -run=Add2Tantum testAdd2 testium causa currere, effectus est

go test -run=Add2 -v
=== RUN   TestAdd2
--- PASS: TestAdd2 (0.00s)
PASS
ok      modu    0.198s
1
2
3
4
5

4. Skip quidam test casibus
Addere novum test munus

func TestAdd3(t *testing.T) {
	if testing.Short() {
        t.Skip("short模式下会跳过该测试用例")
    }
	
	result := Add(3, 2)
	expected := 5
	if result != expected {
		t.Errorf("Add(1,2) return %d, expected %d", result, expected)
	}
}
1
2
3
4
5
6
7
8
9
10
11

cum exequensgo test -shorCum t, erit omittendumtesting.Short()Testis notatus casus, effectus est

go test -short -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
=== RUN   TestAdd2
--- PASS: TestAdd2 (0.00s)
=== RUN   TestAdd3
    calculator_test.go:23: short模式下会跳过该测试用例
--- SKIP: TestAdd3 (0.00s)
PASS
ok      modu    0.635s
1
2
3
4
5
6
7
8
9
10

3. Test coetibus et subtestinis

3.1 Test coetibus et subtestinis

Per circulos testium et subtestinos, plures casus testium addere potes et eventus considerare amiciore modo

func TestAdd(t *testing.T) {
	tests := []struct {
		name     string
		x, y     int
		expected int
	}{
		{"Add1", 1, 2, 3},
		{"Add2", 3, 3, 6},
		{"Add3", 4, 5, 8},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := Add(tc.x, tc.y)
			if result != tc.expected {
				t.Errorf("Add(%d, %d) returned %d, expected %d", tc.x, tc.y, result, tc.expected)
			}
		})
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Currego test -v, Vertere

go test -v
=== RUN   TestAdd
=== RUN   TestAdd/Add2
=== RUN   TestAdd/Add3
    calculator_test.go:51: Add(4, 5) returned 9, expected 8
--- FAIL: TestAdd (0.00s)
    --- PASS: TestAdd/Add1 (0.00s)
    --- PASS: TestAdd/Add2 (0.00s)
    --- FAIL: TestAdd/Add3 (0.00s)
FAIL
exit status 1
FAIL    modu    0.190s
1
2
3
4
5
6
7
8
9
10
11
12

3.2 Parallel probatio

Ire lingua concursum in se adiuvat, sic addendot.Parallel()Ad consequi probat parallelizationem exactoris.

func TestAdd(t *testing.T) {
	t.Parallel()  // 将 TLog 标记为能够与其他测试并行运行
	// 这里使用匿名结构体定义了若干个测试用例
	// 并且为每个测试用例设置了一个名称
	tests := []struct {
		name     string
		x, y     int
		expected int
	}{
		{"Add1", 1, 2, 3},
		{"Add2", 3, 3, 6},
		{"Add3", 4, 5, 8},
	}

	for _, tc := range tests {
		tc := tc  // 注意这里重新声明tt变量（避免多个goroutine中使用了相同的变量）
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()  // 将每个测试用例标记为能够彼此并行运行
			result := Add(tc.x, tc.y)
			if result != tc.expected {
				t.Errorf("Add(%d, %d) returned %d, expected %d", tc.x, tc.y, result, tc.expected)
			}
		})
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3.3 Test coverage

ususgo test -coverad view test coverage

go test -cover
PASS
        modu    coverage: 100.0% of statements
ok      modu    1.149s
1
2
3
4

4. Ite unit toolkit temptationis - Testimonium

Cum unitas explorationis in lingua Go exercenda, cum assertio officialis munus non aedificatur, plerumque magno numero uti necesse est.if...else... dicitur ut quin in test praecessi.Sed utendo bibliothecae tertiae factionis uttestify/assertfacile possumus appellare varias functiones assertionis communiter adhibitas, quae non solum codicem testi simpliciorem reddunt, sed etiam notitiae descriptio errorum perspicua et facilia ad intellegendum generant, adiuvantes nos celeriter problema collocare.

In exemplo superiore utimurif...else...Quod ut quin test eventus

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := Add(tc.x, tc.y)
			if result != tc.expected {
				t.Errorf("Add(%d, %d) returned %d, expected %d", tc.x, tc.y, result, tc.expected)
			}
		})
	}
1
2
3
4
5
6
7
8

Praesto nunctestify/assertProcessus superiori iudicii simplicior sic est:

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := Add(tc.x, tc.y)
			assert.Equal(t, result, tc.expected)
		})
	}
1
2
3
4
5
6

testify/requirehabettestify/assertOmnes assertionis functiones, ea sola differentia esttestify/requireSi casus incassum temptatus offendit, probatio statim terminabitur.

Technology sharing