Tests et tests de performance

GolangGolangBeginner
Pratiquer maintenant

This tutorial is from open-source community. Access the source code

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Ce laboratoire vise à démontrer l'importance des tests unitaires et des tests de performance dans la rédaction de programmes Go conformes aux principes. Le package testing fournit les outils nécessaires pour écrire des tests unitaires, et la commande go test exécute les tests.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL go(("Golang")) -.-> go/TestingandProfilingGroup(["Testing and Profiling"]) go/TestingandProfilingGroup -.-> go/testing_and_benchmarking("Testing and Benchmarking") subgraph Lab Skills go/testing_and_benchmarking -.-> lab-15518{{"Tests et tests de performance"}} end

Tests et tests de performance

Le problème à résoudre dans ce laboratoire est de tester et de mesurer les performances d'une implémentation simple d'une fonction de minimum d'entiers nommée IntMin.

  • Le package testing doit être importé.
  • La fonction IntMin doit prendre deux paramètres entiers et renvoyer un entier.
  • La fonction TestIntMinBasic doit tester la fonction IntMin pour des valeurs d'entrée de base.
  • La fonction TestIntMinTableDriven doit tester la fonction IntMin en utilisant un style table-driven.
  • La fonction BenchmarkIntMin doit mesurer les performances de la fonction IntMin.
## Exécutez tous les tests du projet actuel en mode verbeux.
$ go test -v
== RUN   TestIntMinBasic
--- PASS: TestIntMinBasic (0.00s)
=== RUN   TestIntMinTableDriven
=== RUN   TestIntMinTableDriven/0,1
=== RUN   TestIntMinTableDriven/1,0
=== RUN   TestIntMinTableDriven/2,-2
=== RUN   TestIntMinTableDriven/0,-1
=== RUN   TestIntMinTableDriven/-1,0
--- PASS: TestIntMinTableDriven (0.00s)
    --- PASS: TestIntMinTableDriven/0,1 (0.00s)
    --- PASS: TestIntMinTableDriven/1,0 (0.00s)
    --- PASS: TestIntMinTableDriven/2,-2 (0.00s)
    --- PASS: TestIntMinTableDriven/0,-1 (0.00s)
    --- PASS: TestIntMinTableDriven/-1,0 (0.00s)
PASS
ok  	examples/testing-and-benchmarking	0.023s

## Exécutez tous les tests de performance du projet actuel. Tous les tests
## sont exécutés avant les tests de performance. Le drapeau `bench` filtre
## les noms de fonctions de test de performance avec une expression rationnelle.
$ go test -bench=.
goos: darwin
goarch: arm64
pkg: examples/testing
BenchmarkIntMin-8 1000000000 0.3136 ns/op
PASS
ok  	examples/testing-and-benchmarking	0.351s

Voici le code complet ci-dessous :

// Les tests unitaires sont une partie importante de la rédaction
// de programmes Go conformes aux principes. Le package `testing`
// fournit les outils dont nous avons besoin pour écrire des tests unitaires
// et la commande `go test` exécute les tests.

// Pour la démonstration, ce code est dans le package
// `main`, mais il pourrait être n'importe quel package. Le code de test
// réside généralement dans le même package que le code qu'il teste.
package main

import (
	"fmt"
	"testing"
)

// Nous allons tester cette implémentation simple d'un
// minimum d'entiers. Normalement, le code que nous testons
// serait dans un fichier source nommé par exemple
// `intutils.go`, et le fichier de test pour lui serait ensuite
// nommé `intutils_test.go`.
func IntMin(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// Un test est créé en écrivant une fonction dont le nom
// commence par `Test`.
func TestIntMinBasic(t *testing.T) {
	ans := IntMin(2, -2)
	if ans!= -2 {
		// `t.Error*` signalera les échecs de test mais continuera
		// d'exécuter le test. `t.Fatal*` signalera les échecs de test
		// et arrêtera immédiatement le test.
		t.Errorf("IntMin(2, -2) = %d; want -2", ans)
	}
}

// L'écriture de tests peut être répétitive, il est donc courant
// d'utiliser un *style table-driven*, où les entrées de test et
// les sorties attendues sont listées dans un tableau et une seule boucle
// parcourt le tableau et exécute la logique de test.
func TestIntMinTableDriven(t *testing.T) {
	var tests = []struct {
		a, b int
		want int
	}{
		{0, 1, 0},
		{1, 0, 0},
		{2, -2, -2},
		{0, -1, -1},
		{-1, 0, -1},
	}

	for _, tt := range tests {
		// t.Run permet d'exécuter des "sous-tests", un pour chaque
		// entrée de tableau. Ils sont affichés séparément
		// lors de l'exécution de `go test -v`.
		testname := fmt.Sprintf("%d,%d", tt.a, tt.b)
		t.Run(testname, func(t *testing.T) {
			ans := IntMin(tt.a, tt.b)
			if ans!= tt.want {
				t.Errorf("got %d, want %d", ans, tt.want)
			}
		})
	}
}

// Les tests de performance vont généralement dans des fichiers `_test.go` et sont
// nommés en commençant par `Benchmark`. Le lanceur de test `testing`
// exécute chaque fonction de test de performance plusieurs fois, en augmentant
// `b.N` à chaque exécution jusqu'à ce qu'il ait collecté une mesure précise.
func BenchmarkIntMin(b *testing.B) {
	// Normalement, le test de performance exécute une fonction que nous
	// mesurons dans une boucle `b.N` fois.
	for i := 0; i < b.N; i++ {
		IntMin(1, 2)
	}
}

Résumé

Ce laboratoire a démontré comment écrire des tests unitaires et des fonctions de test de performance en utilisant le package testing en Go. La fonction TestIntMinBasic a testé la fonction IntMin pour des valeurs d'entrée de base, tandis que la fonction TestIntMinTableDriven a utilisé un style table-driven pour tester la fonction IntMin. La fonction BenchmarkIntMin a mesuré les performances de la fonction IntMin.