Cas de test significatifs | Exercices corrigés

Concepts & Exercices

Couverture_{tests} = \frac{Lignes_{exécutées}}{Lignes_{totales}} × 100\%

Calcul de la couverture de tests

Tests unitaires

Fonction isolée

Tester chaque fonction indépendamment

Tests limites

Cas extrêmes

Tester les bornes et valeurs critiques

Tests d'intégration

Interaction modules

Tester l'interaction entre composants

Types de tests :

Tests unitaires : Vérifier chaque fonction individuellement
Tests limites : Tester les cas extrêmes
Tests d'intégration : Vérifier les interactions
Tests de régression : S'assurer qu'on n'a rien cassé

Exercice 1

Tests unitaires pour une fonction de calcul de moyenne

Exercice 2

Tests limites pour une fonction de conversion

Exercice 3

Tests d'intégration pour un module de gestion

Exercice 4

Tests de régression pour une fonction existante

Exercice 5

Analyse de couverture de code

Corrigé : Exercices 1 à 3

1 Tests unitaires moyenne

Définition :

Problème : Tester unitairement une fonction de calcul de moyenne

Méthode de test unitaire :

Identifier la fonction à tester
Créer des cas de test pour chaque scénario
Tester les cas normaux, limites et erreurs
Valider les résultats obtenus

Créer la fonction

Définir les cas de test

Exécuter les tests

Valider les résultats

Étape 1 : Fonction à tester

FONCTION CalculMoyenne(liste_notes) : Réel
  SI LONGUEUR(liste_notes) = 0 ALORS
    RETOURNER 0
  FIN SI
  
  somme ← 0
  POUR note IN liste_notes FAIRE
    somme ← somme + note
  FIN POUR
  
  RETOURNER somme / LONGUEUR(liste_notes)
FIN

Étape 2 : Cas de test significatifs

• Cas normal : [10, 15, 12] → 12.33
• Liste vide : [] → 0
• Un seul élément : [15] → 15
• Nombres décimaux : [8.5, 9.5, 10] → 9.33
• Nombres négatifs : [-5, -10, -15] → -10

Étape 3 : Exécution des tests

# Test 1 : Cas normal
resultat1 ← CalculMoyenne([10, 15, 12])
ASSERT resultat1 = 12.33 (arrondi à 2 décimales)

# Test 2 : Liste vide
resultat2 ← CalculMoyenne([])
ASSERT resultat2 = 0

# Test 3 : Un seul élément
resultat3 ← CalculMoyenne([15])
ASSERT resultat3 = 15

# Test 4 : Nombres décimaux
resultat4 ← CalculMoyenne([8.5, 9.5, 10])
ASSERT resultat4 = 9.33 (arrondi à 2 décimales)

Tests unitaires complets pour la fonction CalculMoyenne

Évaluation :

Tests couvrant les cas normaux, limites et erreurs. Bonne couverture fonctionnelle.

Règles de test unitaire :

• Tester chaque fonction individuellement : Isoler la fonction

• Couvrir tous les chemins : Tous les branches de code

• Valider les cas limites : Bornes et erreurs possibles

2 Tests limites conversion

Définition :

Problème : Tester une fonction de conversion avec des cas limites

Identifiez les bornes

Testez les limites inférieures

Testez les limites supérieures

Testez les cas limites

Étape 1 : Fonction de conversion

FONCTION CelsiusVersFahrenheit(temp_celsius) : Réel
  SI temp_celsius < -273.15 ALORS
    ERREUR "Température impossible"
    RETOURNER -1
  FIN SI
  
  RETOURNER temp_celsius * 9/5 + 32
FIN

Étape 2 : Cas limites significatifs

• Limite inférieure : -273.15°C (zéro absolu) → -459.67°F
• Juste en-dessous : -274°C → Erreur
• Juste au-dessus : -273°C → -459.4°F
• Valeurs extrêmes : 1000°C, -1000°C
• Valeurs frontières : 0°C → 32°F, 100°C → 212°F

Étape 3 : Tests limites

# Test limite inférieure
resultat1 ← CelsiusVersFahrenheit(-273.15)
ASSERT resultat1 = -459.67

# Test en-dessous de la limite
resultat2 ← CelsiusVersFahrenheit(-274)
ASSERT resultat2 = -1  # Indique une erreur

# Test juste au-dessus de la limite
resultat3 ← CelsiusVersFahrenheit(-273)
ASSERT resultat3 = -459.4

# Test frontière normale
resultat4 ← CelsiusVersFahrenheit(0)
ASSERT resultat4 = 32

# Test frontière normale
resultat5 ← CelsiusVersFahrenheit(100)
ASSERT resultat5 = 212

Tests limites complets pour la conversion de température

Évaluation :

Tests couvrant les bornes physiques et les valeurs critiques. Bonne gestion des erreurs.

Règles de test limite :

• Tester les bornes inférieures et supérieures : Valeurs extrêmes

• Tester les cas frontières : Juste avant/après les seuils

• Tester les cas d'erreur : Conditions invalides

3 Tests d'intégration gestion

Définition :

Problème : Tester l'intégration entre modules de gestion

Intégration = \sum_{i=1}^{n} Interfaces_i × Fiabilité_i

Test_{intégration} = Test_{unitaires} + Test_{interfaces}

Étape 1 : Modules à tester

Module GestionContacts
├── FONCTION AjouterContact(nom, email)
├── FONCTION RechercherContact(email)
├── FONCTION ModifierContact(email, nouveau_nom)
└── FONCTION SupprimerContact(email)

Module GestionGroupes
├── FONCTION CreerGroupe(nom)
├── FONCTION AjouterAuGroupe(contact_email, groupe_nom)
└── FONCTION ObtenirContactsGroupe(groupe_nom)

Étape 2 : Scénarios d'intégration

• Ajouter un contact puis le rechercher
• Ajouter un contact, le mettre dans un groupe, puis lister les contacts du groupe
• Modifier un contact, puis le rechercher pour confirmer la modification
• Supprimer un contact, puis vérifier qu'il n'est plus trouvable

Étape 3 : Tests d'intégration

# Scénario 1 : Ajouter et rechercher
AjouterContact("Jean Dupont", "jean@example.com")
contact_trouve ← RechercherContact("jean@example.com")
ASSERT contact_trouve.nom = "Jean Dupont"

# Scénario 2 : Ajouter au groupe et récupérer
CreerGroupe("Amis")
AjouterContact("Marie Martin", "marie@example.com")
AjouterAuGroupe("marie@example.com", "Amis")
contacts_groupe ← ObtenirContactsGroupe("Amis")
ASSERT "marie@example.com" IN contacts_groupe

# Scénario 3 : Modification et recherche
ModifierContact("jean@example.com", "Jean Martin")
contact_modifie ← RechercherContact("jean@example.com")
ASSERT contact_modifie.nom = "Jean Martin"

Tests d'intégration couvrant les interactions entre modules

Évaluation :

Tests couvrant les flux complets d'interaction entre modules. Bonne couverture fonctionnelle.

Règles de test d'intégration :

• Tester les interfaces : Communication entre modules

• Simuler des scénarios réels : Flux complets d'utilisation

• Vérifier la cohérence des données : Propagation correcte

Corrigé : Exercices 4 à 5

4 Tests de régression

Définition :

Problème : Mettre en place des tests de régression

Tests existants

Anciens cas

Tests qui ont déjà été exécutés

Nouveaux tests

Fonctionnalités

Tests pour les nouvelles fonctionnalités

Tests de régression

Tous les tests

Tests existants + nouveaux

Étape 1 : Ancienne version de la fonction

FONCTION CalculPrixTotal(prix_unitaire, quantite) : Réel
  retour ← prix_unitaire * quantite
  RETOURNER retour
FIN

Étape 2 : Nouvelle version avec remise

FONCTION CalculPrixTotal(prix_unitaire, quantite, taux_remise) : Réel
  total_brut ← prix_unitaire * quantite
  remise ← total_brut * taux_remise
  retour ← total_brut - remise
  RETOURNER retour
FIN

Étape 3 : Tests de régression

# Tests existants (doivent toujours passer)
resultat1 ← CalculPrixTotal(10, 5, 0)  # Pas de remise
ASSERT resultat1 = 50

resultat2 ← CalculPrixTotal(100, 1, 0.1)  # 10% de remise
ASSERT resultat2 = 90

# Tests de nouvelle fonctionnalité
resultat3 ← CalculPrixTotal(100, 2, 0.2)  # 20% de remise
ASSERT resultat3 = 160

# Tests limites
resultat4 ← CalculPrixTotal(10, 0, 0.5)  # Quantité zéro
ASSERT resultat4 = 0

resultat5 ← CalculPrixTotal(50, 10, 1)   # Remise de 100%
ASSERT resultat5 = 0

Tests de régression garantissant la non-régression

Évaluation :

Tous les tests existants passent, nouveaux cas couverts. Aucune régression introduite.

Règles de test de régression :

• Conserver les anciens tests : S'assurer qu'ils continuent à passer

• Ajouter des tests pour nouvelles fonctionnalités : Couvrir les modifications

• Automatiser les tests : Exécuter régulièrement

5 Analyse de couverture

Définition :

Problème : Analyser la couverture de code des tests

Identifier le code à tester

Créer les tests

Mesurer la couverture

Améliorer la couverture

Étape 1 : Code à analyser

FONCTION ClassificationAge(age) : Chaîne
  SI age < 0 ALORS                 // Ligne 1
    RETOURNER "Erreur"             // Ligne 2
  SINON SI age < 12 ALORS          // Ligne 3
    RETOURNER "Enfant"             // Ligne 4
  SINON SI age < 18 ALORS          // Ligne 5
    RETOURNER "Adolescent"         // Ligne 6
  SINON SI age < 65 ALORS          // Ligne 7
    RETOURNER "Adulte"             // Ligne 8
  SINON                            // Ligne 9
    RETOURNER "Senior"             // Ligne 10
  FIN SI
FIN

Étape 2 : Tests existants

# Test 1 : Adulte
resultat1 ← ClassificationAge(30)
ASSERT resultat1 = "Adulte"

# Test 2 : Adolescent
resultat2 ← ClassificationAge(15)
ASSERT resultat2 = "Adolescent"

# Test 3 : Senior
resultat3 ← ClassificationAge(70)
ASSERT resultat3 = "Senior"

Étape 3 : Analyse de la couverture

Ligne	Code	Exécutée	Commentaire
1	SI age < 0 ALORS	Non	Manque test avec age < 0
2	RETOURNER "Erreur"	Non	Manque test avec age < 0
3	SINON SI age < 12 ALORS	Non	Manque test avec age < 12
4	RETOURNER "Enfant"	Non	Manque test avec age < 12
5	SINON SI age < 18 ALORS	Oui	Testé avec age = 15
6	RETOURNER "Adolescent"	Oui	Testé avec age = 15
7	SINON SI age < 65 ALORS	Oui	Testé avec age = 30
8	RETOURNER "Adulte"	Oui	Testé avec age = 30
9	SINON	Oui	Testé avec age = 70
10	RETOURNER "Senior"	Oui	Testé avec age = 70

Étape 4 : Calcul de la couverture

Couverture = (6 lignes exécutées / 10 lignes totales) × 100% = 60%

Manquent des tests pour : Enfant (age < 12) et Erreur (age < 0)

Couverture actuelle : 60% - Besoin d'améliorer à 100%

Évaluation :

Couverture insuffisante. Ajouter des tests pour atteindre 100% de couverture.

Règles de couverture :

• Maximiser la couverture : Viser 100% de couverture de ligne

• Tester tous les chemins : Toutes les branches de code

• Améliorer continuellement : Ajouter des tests manquants

Cours bien détaillé

Qualité_{tests} = \frac{Cas_{significatifs}}{Cas_{possibles}} × 100\%

Mesure de la qualité des tests

🎯

Tests unitaires : Tester chaque fonction individuellement.

🔍

Tests limites : Tester les cas extrêmes et erreurs.

🔗

Tests d'intégration : Tester l'interaction entre modules.

🔄

Tests de régression : S'assurer qu'on n'a rien cassé.

💡

Conseil : Commencer par les tests unitaires avant les tests d'intégration

🔍

Attention : Ne pas négliger les cas limites

⚡

Astuce : Automatiser l'exécution des tests

📋

Méthode : Documenter les résultats des tests

✅

Vérification : Maintenir une couverture élevée

Méthodes de test :

Partitionnement équivalent : Regrouper les entrées en classes similaires
Analyse des valeurs limites : Tester les frontières des domaines
Test basé sur les chemins : Couvrir tous les chemins d'exécution
Test par mutation : Introduire des erreurs pour tester la sensibilité

Règles importantes :

Un test doit être indépendant des autres tests
Les tests doivent être reproductibles et déterministes
Il faut tester les cas normaux, limites et d'erreur
La couverture de code n'est pas suffisante, il faut aussi tester la logique

Points clés à retenir :

Significativité : Les tests doivent être pertinents et couvrir les cas importants
Complétude : Couvrir tous les aspects critiques du programme
Automatisation : Rendre les tests exécutables automatiquement
Maintenance : Mettre à jour les tests avec les évolutions du code

Cas de test significatifsExercices corrigés

Cas de test significatifs
Exercices corrigés