méthode de test de test Golang

Le langage Go est un langage de programmation rapide, sûr et simple, il prend également en charge les tests et est très convivial. Lors du développement et des tests dans Golang, cela peut améliorer la qualité et la précision du code, facilitant ainsi les itérations des développeurs pendant le développement du projet.

Cet article présentera les méthodes de test dans Golang, y compris les tests unitaires, les tests de référence, les tests de performances et les tests de limites. Nous partagerons des cas de test et des techniques de test courants pour aider les lecteurs à mieux comprendre les méthodes et compétences de test de Golang, et à améliorer l'efficacité et la qualité du développement.

1. Test unitaire

1. Cadre de base du cas de test

Le cadre de base des cas de test est :

func TestFunctionName(t *testing.T) {
    // testing function
}

TestFunctionName est le nom de la méthode de test, qui doit commencer par Test, et le FunctionName suivant peut être nommé arbitrairement. testing.T est un contexte de test, utilisé pour planifier les méthodes d'accès aux tests et enregistrer l'état des tests. Il peut être utilisé pour signaler les échecs et les erreurs lors des tests et afficher les résultats des tests sur la console.

Par exemple de code :

package main

import "testing"

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

func TestSum(t *testing.T) {
    got := Sum(1, 2)
    want := 3

    if got != want {
        t.Errorf("Sum(1,2) = %d; want %d", got, want)
    }
}

Lors de l'exécution du programme, si le résultat de sortie est incohérent avec les attentes, un message d'erreur sera affiché, par exemple :

--- FAIL: TestSum (0.00s)
    main_test.go:11: Sum(1,2) = 4; want 3
FAIL
exit status 1
FAIL        command-line-arguments  0.005s

2.Nom et organisation du cas de test

Méthode de test de Golang. les noms doivent être préfixés par Test , ce qui permet au framework de test de les reconnaître automatiquement et de les exécuter lors de l'exécution de la commande go test. Dans le même temps, afin d'éviter les conflits avec d'autres méthodes de test portant le même nom, la dénomination des méthodes de test doit garantir leur unicité.

Afin de mieux organiser les cas de tests, vous pouvez ajouter quelques identifiants identifiables devant les cas de tests, tels que :

• TestXxx, BenchmarkXxx, ExempleXxx Lors de l'exécution de l'exemple dans le navigateur, exécutez la fonction correspondante, en utilisant. Xxx comme nom de fonction, la partie devant Xxx ne peut pas être Test, Benchmark, Exemple, Sortie, Entrée ou Erreur, et la première lettre ne peut pas être une lettre minuscule [a-z]
• TestXxxShort n'exécutera cette méthode de test qu'en cours de route commande de test. Par exemple : TestParseShort()
• TestXxxParallel peut s'exécuter en parallèle et t.Parallel() peut être utilisé pour améliorer l'efficacité des tests. Par exemple : TestFooParallel()

3. Objectifs et mise en œuvre des cas de test

Grâce aux tests unitaires, la qualité et l'exactitude du code Golang peuvent être vérifiées, notamment :

• Si la fonction renvoie les résultats attendus
• Si elle répond au runtime Si la logique de traitement
• peut gérer des situations inattendues

Par exemple, le code :

// Add 两个整数x和y
func Add(x, y int) int {
    return x + y
}

Code de test correspondant :

func TestAdd(t *testing.T) {
    cases := []struct {
        in1, in2, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, c := range cases {
        got := Add(c.in1, c.in2)
        if got != c.want {
            t.Errorf("Add(%d, %d) == %d, want %d", c.in1, c.in2, got, c.want)
        }
    }
}

Le framework de test de Go nous permet de créer des cas de test avec des structures de contrôle, telles que des boucles, des branches, et exceptions Gestion des erreurs. Lors du test du code, vous vérifiez que le code se comporte comme prévu en transmettant les paramètres d'entrée à une fonction et en comparant la valeur de sortie de la fonction à la valeur attendue.

2. Test de référence

Le test de référence Golang est utilisé pour comparer les différences de performances des codes dans différentes situations. Les benchmarks exécutent le code plusieurs fois et comparent les temps d'exécution. S'il existe une différence de vitesse, vous pouvez déterminer quelle implémentation est la plus rapide.

Le cadre de base des tests de référence est :

func BenchmarkFunctionName(b *testing.B) {
    // Testing code
}

Parmi eux, BenchmarkFunctionName représente le nom de la méthode de test de référence, qui doit commencer par Benchmark, et le FunctionName suivant peut être nommé arbitrairement. testing.B est le contexte de test, utilisé pour contrôler l'état et l'itération du test. Pendant les tests d'évaluation, vous pouvez l'utiliser pour contrôler le nombre d'exécutions de tests, détecter les erreurs pouvant survenir lorsque les tests sont arrêtés et d'autres problèmes.

Par exemple de code :

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(1, 2)
    }
}

Lorsque le programme s'exécute, le résultat de sortie est le suivant :

BenchmarkAdd-4        2000000000             0.29 ns/op
PASS
ok      _/Users/test/main    1.028s

Parmi eux,

• "BenchmarkAdd" représente le nom du test de référence
• "4" représente le nombre de goroutines exécuté en parallèle par la fonction test
• "2000000000 "Indique le nombre total d'itérations exécutées par testing.B.Run Le nombre de chaque itération de l'équilibrage adaptatif interne du langage Go
• "0,29 ns/op" indique que la moyenne le temps requis pour chaque itération est de 0,29 nanosecondes.

3. Test de performances

Le test de performances est utilisé pour tester les performances du programme pendant un fonctionnement à long terme. Par exemple :

func TestPerfAdd(t *testing.T) {
    for i := 0; i < 100000; i++ {
        Add(1, 2)
    }
}

Parmi eux, la boucle de test exécute la fonction 100 000 fois pour tester ses problèmes de performances lors d'une exécution prolongée. Idéal pour tester les performances d'un programme contre les fuites de mémoire, les fuites de gestion de fichiers ou d'autres fuites de ressources.

4. Tests de limites

Les tests de limites sont utilisés pour tester dans quelle mesure le code gère les conditions aux limites, par exemple :

func TestBubbleSort(t *testing.T) {
    tests := []struct {
        name string
        in   []int
        want []int
    }{
        {"Sorted", []int{1, 2, 3, 4, 5}, []int{1, 2, 3, 4, 5}},
        {"Reverse", []int{5, 4, 3, 2, 1}, []int{1, 2, 3, 4, 5}},
        {"FewElement", []int{5, 3}, []int{3, 5}},
        {"Duplicate", []int{5, 3, 5, 2, 2}, []int{2, 2, 3, 5, 5}},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            BubbleSort(tt.in)
            if !reflect.DeepEqual(tt.in, tt.want) {
                t.Errorf("test case %s expects %v but actual is %v",
                    tt.name, tt.want, tt.in)
            }
        })
    }
}

Les tests de limites peuvent vérifier si le programme répond aux attentes lors de la gestion des conditions de limite, par exemple :

• gère certaines entrées anormales (par exemple nombres négatifs, 0, valeurs maximales/minimales)
• Placez le programme dans la situation de traitement la plus rapide ou la plus lente (par exemple la taille des données est 0 ou la valeur maximale)
• Définissez les limites supérieure et inférieure pour divers paramètres de la fonction et tester la fonction Réactions

Résumé

Lorsque vous testez le code Golang, vous devez tenir compte de la diversité des cas de test afin de pouvoir fournir des tests utiles et complets pour différentes parties du programme. Le cadre de test Golang prend en charge les tests unitaires, les tests de référence, les tests de performances et les tests de limites, et nous pouvons choisir en fonction des besoins réels. Non seulement cela, nous devons également suivre certaines bonnes pratiques de test, telles que la normalisation de la dénomination des méthodes de test, l'allocation rationnelle des tâches de test, l'extraction de la logique des tests répétés et la facilitation de l'exécution rapide des tests. Je pense qu'après avoir maîtrisé ces compétences de test, les lecteurs seront en mesure d'effectuer des tests de code plus approfondis lors du développement de Golang et d'améliorer l'efficacité des tests et la qualité du code de développement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!