Aller au contenu

Exercices#

Écrire des tests unitaires pour une application de calculatrice#

Définir les fonctions de l'application calculatrice#

  • L'application de calculatrice doit comporter au moins les quatre opérations de base : addition, soustraction, multiplication et division.
  • Pour chaque opération, créer une fonction dans Go. Par exemple, une fonction Add(a int, b int) int pour l'addition.

Créer des tests unitaires pour les différentes opérations#

  • Pour chaque fonction définie précédemment, créer une fonction de test correspondante. Par exemple, pour tester la fonction d'addition, créer une fonction TestAdd(t *testing.T).
  • À l'intérieur de cette fonction de test, vérifier que la fonction Add() donne le résultat attendu. Par exemple :
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d; want 5", result)
    }
}

Utiliser des table-driven tests pour les tests unitaires#

  • Au lieu de répéter le code de test pour différents cas, utiliser les tests table-driven de Go. C'est une méthode où vous définissez une table de cas de test, et vous exécutez le test pour chaque cas de la table.
  • Par exemple :
func TestAdd(t *testing.T) {
    var tests = []struct {
        a, b, want int
    }{
        {2, 3, 5},
        {4, -2, 2},
        {-4, -6, -10},
        {0, 5, 5},
    }

    for _, tt := range tests {
        if got := Add(tt.a, tt.b); got != tt.want {
            t.Errorf("Add(%v, %v) = %v; want %v", tt.a, tt.b, got, tt.want)
        }
    }
}

Exécuter les tests et analyser les résultats#

  • Utiliser la commande go test pour exécuter les tests.
  • L'outil de test Go affiche un résumé des tests réussis et échoués.
  • Si des tests échouent, l'outil de test affiche également les valeurs attendues et obtenues, ce qui aide à identifier où le problème se pose.

Analyser et optimiser les performances d'un programme#

Choisir un programme à optimiser#

  • Choisir un programme qui présente des problèmes de performance ou qui est susceptible de s'améliorer. Cela peut être une partie de l'application de calculatrice ou un autre programme Go que vous avez écrit.

Profiler le programme à l'aide de "pprof" pour identifier les goulots d'étranglement#

  • Importer le package net/http/pprof dans le programme.
  • Démarrer un serveur web pour accéder aux profils de performance en utilisant http.ListenAndServe("localhost:6060", nil).
  • Accéder à http://localhost:6060/debug/pprof/ pour voir les profils disponibles.
  • Utiliser go tool pprof pour analyser les profils et identifier les goulots d'étranglement.

Appliquer des techniques d'optimisation pour améliorer les performances#

  • Les techniques d'optimisation dépendent du problème spécifique identifié. Cela peut

impliquer de réduire l'utilisation de la mémoire, d'optimiser l'utilisation du CPU, d'améliorer l'algorithmique, etc. * Par exemple, pour réduire l'allocation de mémoire, réutiliser les tampons au lieu de les créer à chaque fois.

Mesurer les améliorations à l'aide des benchmarks et du profiling#

  • Écrire des benchmarks pour les fonctions que vous optimisez en utilisant le package testing de Go.
  • Exécuter les benchmarks en utilisant go test -bench=..
  • Comparer les résultats avant et après l'optimisation pour vérifier que les performances ont été améliorées.