Qu'est-ce que le test de mutation: tutoriel avec des exemples

what is mutation testing

Essayez Notre Instrument Pour Éliminer Les Problèmes

Sélectionnez Le Système D'Exploitation Choisissez Un Programme De Projection (Éventuellement)

Décrivez Votre Problème

Ce tutoriel explique ce qu'est le test de mutation, comment l'exécuter et les types de test de mutation avec des exemples:

Qu'est-ce que le test de mutation?

Le test de mutation est une technique de test basée sur les défauts dans laquelle les variations d'un programme logiciel sont soumises à l'ensemble de données de test. Ceci est fait pour déterminer l'efficacité de l'ensemble de test pour isoler les écarts.

Cela semble un peu compliqué, n'est-ce pas?

Ce que vous apprendrez:

Test de mutation
Conclusion
- lecture recommandée

Test de mutation

Le test de mutation (MT) va très loin, remontant aux années 70 où il a été proposé pour la première fois en tant que projet scolaire. Il a été radié car il exigeait beaucoup de ressources. Cependant, alors que les humains continuaient à développer des ordinateurs plus avancés, il a lentement fait son retour et est maintenant l'une des techniques de test les plus populaires.

Définition des tests de mutation

MT est également connu sous le nom de tests basés sur les défauts, mutation du programme, tests basés sur les erreurs, ou analyse de mutation .

Comme son nom l'indique, le test de mutation est un type de test logiciel basé sur des changements ou des mutations. Des modifications minuscules sont introduites dans le code source pour vérifier si les cas de test définis peuvent détecter des erreurs dans le code.

Le cas idéal est qu'aucun des cas de test ne devrait réussir. Si le test réussit, cela signifie qu'il y a une erreur dans le code. Nous disons que le mutant (la version modifiée de notre code) a vécu. Si le test échoue, il n'y a pas d'erreur dans le code et le mutant a été tué. Notre objectif est de tuer tous les mutants.

Les tests de mutation permettent également de tester la qualité des cas de test définis ou des suites de tests avec une offre pour écrire des cas de test plus efficaces. Plus nous pouvons tuer de mutants, meilleure est la qualité de nos tests.

Concepts de test de mutation

Avant de discuter davantage des tests de mutation, explorons certains concepts que nous rencontrerons.

# 1) Mutants: C'est simplement la version mutée du code source. C'est le code qui contient des changements infimes. Lorsque les données de test sont exécutées à travers le mutant, elles devraient idéalement nous donner des résultats différents du code source d'origine. Les mutants sont également appelés programmes mutants .

Il existe différents types de mutants. Ce sont les suivants:

Mutants survivants: Comme nous l'avons mentionné, ce sont les mutants qui sont toujours en vie après l'exécution des données de test via les variantes d'origine et mutées du code source. Ceux-ci doivent être tués. Ils sont également connus sous le nom de mutants vivants.
Mutants tués: Ce sont des mutants qui sont tués après un test de mutation. Nous les obtenons lorsque nous obtenons des résultats différents des versions originales et mutées du code source.
Mutants équivalents: Ceux-ci sont étroitement liés aux mutants vivants, en ce sens qu’ils sont «vivants» même après avoir exécuté des données de test à travers eux. Ce qui les différencie des autres, c'est qu'ils ont la même signification que le code source d'origine, même s'ils peuvent avoir une syntaxe différente.

# 2) Mutateurs / opérateurs de mutation: C’est ce qui rend les mutations possibles, elles sont sur le «siège du conducteur». Ils définissent essentiellement le type d'altération ou de changement à apporter au code source pour avoir une version mutante. Ils peuvent être appelés défauts ou règles de mutation .

# 3) Score de mutation: Il s'agit d'un score basé sur le nombre de mutants.

Il est calculé à l'aide de la formule ci-dessous:

Score de mutation

Notez que, les mutants équivalents ne sont pas pris en compte lors du calcul du score de mutation. Le score de mutation est également connu sous le nom de adéquation des mutations . Notre objectif doit être d'atteindre un score de mutation élevé.

Comment faire des tests de mutation

Étape 1: Écrivons notre test unitaire Jasmine.

Suite de tests (Jasmine)

 describe('User', function() { it('should compare the two numbers from user input', function(){ expect(20).toBeGreaterThan(5); }) });

Suite de tests (Jasmine)

Étape 2: Écrivez le code original.

Code d'origine (Javascript)

 const user_info = () => { mother_age = parseInt(prompt('Enter mother's age')) daughter_age = parseInt(prompt('Enter daughter's age')) if (mother_age > daughter_age) { alert(`Daughter's age is ${daughter_age}. Mother's age is ${mother_age}. Welcome to the Mother-Daughter program`) } else { alert(`Daughter's age: ${daughter_age}, is more than mother's age: ${mother_age}. Please enter correct ages`) } } user_info();

Original code (mother_age></p> <p><span style= Étape 3: Nous exécuterons ensuite le test via le code d'origine pour nous assurer que nous n'avons pas échoué aux tests dès le départ. Nous devrions avoir une sortie qui indique que nous avons effectivement écrit un test sans échec.

Par exemple:

Sortie avec zéro échec

terminé en 0.019s 1 spécification, 0 échec, randomisé avec la graine 31435

Résultat du code d'origine:

Daughter's age is 5. Mother's age is 20. Welcome to the Mother-Daughter program

Étape 4: Présentez le mutant. Dans ce cas, nous modifions le plus grand que opérateur (mother_age> daughter_age) à un inférieur à opérateur (mother_age

Code mutant (Javascript)

const user_info = () =>{ mother_age = parseInt(prompt('Enter mother's age')) daughter_age = parseInt(prompt('Enter daughter's age')) if (mother_age  
  Étape n ° 5: Nous exécutons ensuite le test via le code mutant.
  Voici les résultats des tests: 
  
   terminé en 0,017 s 1 spécification, 0 échec, randomisé avec la graine 89555  
  Résultat du code mutant: 
Daughter's age: 5, is more than mother's age: 20. Please enter correct ages Étape # 6: Comparez les résultats de la version originale et de la version mutante. Dans ce cas, ils sont différents, même si la même suite de tests a été utilisée. Nous avons donc tué notre mutant. Notre suite de tests est donc prête à fonctionner.
 Types de tests de mutation
 Il existe plusieurs types de mutations. Celles-ci sont expliquées ci-dessous.
 # 1) Mutation de valeur
  Ici, nous introduisons une mutation en modifiant le paramètre et / ou les valeurs constantes, généralement de +/- 1. 
  Exemple: code d'origine (Javascript) 
 let arr = (2,3,4,5) for(let i=0; i  
 Si le code ci-dessus était destiné à multiplier les nombres pairs où je<4 , alors la mutation de valeur signifierait changer l'initialisation en soit i = 1 .
  Exemple: code mutant (Javascript) 
 let arr = (2,3,4,5) for(let i=1; i  
 # 2) Mutation de déclaration
 Ici, nous supprimons ou dupliquons une instruction dans un bloc de code. Nous pourrions également réorganiser les instructions dans un bloc de code.
  Dans un bloc if-else, par exemple, nous pourrions supprimer la partie else ou même tout le bloc if-else. 
  Exemple: code d'origine (Javascript) 
 let arr = (2,3,4,5) for(let i=0; i  
  Exemple: code mutant (Javascript) 
 let arr = (2,3,4,5) for(let i=0; i  
 # 3) Mutation de décision
 La cible ici est le code qui prend les décisions, par exemple, comparaisons de valeurs. Nous pouvons changer > à< comme dans notre exemple de programme mère-fille.
  Les autres opérateurs que nous pouvons changer sont les suivants: 
    Opérateur d'origine Opérateur mutant  
 
   1 <= > =  
   deux > = ==  
   3 === ==  
   4 et ou  
   5 || &&  
 
 
  Les avantages des tests de mutation (MT) comprennent: 
  MT couvre une grande partie de la logique du code.
 Nous pouvons tester des parties spécifiques du code, et pas seulement chemins , branches , ou déclarations .
 Avec MT, nous pouvons détecter même les erreurs faciles à contourner.
 Cela nous aide à évaluer la qualité de notre suite de tests et à nous ajuster en conséquence.
 
  Les inconvénients des tests de mutation (MT) comprennent: 
  Il est gourmand en ressources car il existe un grand nombre de mutants qui sont généralement générés pour chaque bloc de code.
 Nous devons contre-vérifier les mutants survivants, car certains ne sont pas valides.
 
 Outils de test de mutation
 Les outils sont utiles pour accélérer le processus de génération de mutants. Voici quelques outils que nous pouvons utiliser dans MT: Stryker, Jumble, PIT et Insure ++.
 En savoir plus sur les tests de mutation
  Apprenons d'un exemple:  
   
 Disons qu'il existe un site hospitalier qui permet aux nouveaux utilisateurs de s'inscrire. Il lit la date de naissance ou l'âge du patient. S'il est supérieur à 14, désigne un médecin généraliste comme médecin principal. Pour ce faire, il invoque la fonction de «médecin généraliste» qui recherche le médecin disponible.
 Maintenant, il pourrait y avoir d'autres fonctionnalités. Peut-être que les patients de moins de 13 ans sont assignés à un pédiatre et ainsi de suite. Mais nous ne prendrons que le cas des plus de 14 ans.
 Voici à quoi pourrait ressembler le code:
   1) Lire l'âge  
   deux) Si l'âge> 14  
   3) Médecin = Médecin Général ()  
   4) Fin si 
 Veuillez noter que les lignes de code ci-dessus ne sont spécifiques à aucun langage de programmation et ne fonctionneront pas. C'est juste hypothétique.
 En tant que testeur, si mon ensemble de données est 14, 15, 0, 13 - quelques nombres aléatoires.
 L'objectif est de vérifier si l'ensemble de données des 4 valeurs (14, 15, 0 et 3) est adéquat pour identifier tous les problèmes possibles avec ce code.
   Lire aussi => Conseils pour concevoir des données de test avant d'exécuter vos cas de test  
  Comment le test de mutation y parvient-il? 
 Tout d'abord, vous créez des mutants-variations du programme. Un mutant n'est rien d'autre qu'un programme qui s'écrit comme une déviation. Il contient un défaut auto-amorcé.
 Des exemples sont:
  Remplacement de l'opérateur arithmétique
 Remplacement du connecteur logique
 Suppression de déclaration
 Remplacement de l'opérateur relationnel
 Insertion de valeur absolue, etc.
 
 Ces remplacements sont également appelés «Opérateurs de mutation». 
  Laissez-moi vous montrer des exemples: 
  Mutant # 1: opérateur relationnelremplacement 
  1) Âge de lecture  
  2) Si l'âge avec<’  
  3) Médecin = Médecin généraliste ()  
  4) Fin si 
  Mutant n ° 2: 
  1) Âge de lecture  
  2) Si age = 14 «Changer le> avec =»  
  3) Médecin = Médecin généraliste ()  
  4) Fin si 
  Mutant n ° 3: 
  1) Âge de lecture  
  2) Si age> = 14 «Changer le> avec> =»  
  3) Médecin = Médecin généraliste ()  
  4) Fin si 
  Mutant n ° 4: 
  1) Âge de lecture  
  2) Si l'âge avec<=’  
  3) Médecin = Médecin généraliste ()  
  4) Fin si 
  Mutant n ° 5: suppression de déclaration 
  1) Âge de lecture  
  2) Si âge = 14  
  3) «supprimer la déclaration de mission du médecin»  
  4) Fin si 
  Mutant # 6: Insertion de valeur absolue 
  1) Âge de lecture  
  2) Si l'âge> 14  
  3) Docteur = Mr.X (insertion de valeur absolue - disons que X est pédiatre)  
  4) Fin si 
  Mutant # 7: syntaxe incorrecte 
  1) Âge de lecture  
  2) Si age %% 14 (syntaxe incorrecte)  
  3) Médecin = Médecin généraliste ()  
  4) Fin si 
  Mutant # 8: fait la même chose que le test original 
  1) Âge de lecture  
  2) Si l’âge> 14 ans et> 14 ans «signifie la même chose que l’âge> 14 ans»  
  3) Médecin = Médecin généraliste ()  
  4) Fin si 
 Une fois, tous les mutants sont créés. Ils sont soumis à l'ensemble de données de test. Notre ensemble est 14, 15, 0 et 13. Lequel de ces mutants notre ensemble de données trouvera-t-il?
  Découvrez dans le tableau ci-dessous: 
   (Cliquez sur l'image pour une vue agrandie)  
  
 Comme vous pouvez le voir, notre valeur de données 14 trouve des échecs lorsqu'elle s'exécute contre, Mutant 2, 3 et 4. Ou, 14 tue les mutants 2, 3 et 4. Mais, elle est inefficace contre, 1, 6 et 8.
  Si votre ensemble de données tue tous les mutants, il est efficace. Sinon, incluez des données de test plus ou meilleures. Il n'est pas nécessaire que chaque valeur de l'ensemble de données tue tous les mutants. Mais ensemble, ils devraient tout tuer.Par exemple:14 tue 2, 3 et 4. 15 tue 1, 2 et 4. Et ainsi de suite.
  Qu'en est-il de 5, 7 et 8? 
  Mutant # 5 - est l'instance de programme qui échouera quelle que soit la valeur de données que vous donnez. C'est parce qu'il ne fera aucune programmation pour les valeurs valides et non valides.
  Mutant n ° 7   - sera une erreur de compilation. Ou dans le cas d'un langage de script, une erreur qui empêchera l'exécution.
  Mutant # 8   - est la même chose que le programme principal.
 Comme vous pouvez le voir, les mutants ci-dessus ne sont pas du tout utiles.
  Par conséquent, les mutants à éviter sont: 
   Mutants syntaxiquement incorrects / «mort-nés». : Vous n'avez besoin que de mutants syntaxiquement corrects.Exemple:Mutant 7
  Mutants équivalents: Ceux qui font exactement la même chose que le programme original.Exemple:Mutant 8.
  Trivial Mutant: Peut être tué par n'importe quel ensemble de données.Exemple:Mutant 5
 
 Points à noter
  Le nombre de mutants, même pour un petit programme, peut être élevé. C'est un nombre fini, mais toujours très grand. Pour cette raison, un sous-ensemble de mutants est généralement utilisé. Il est courant de choisir des mutants au hasard.
 Les opérateurs de mutation listés ci-dessus ne sont pas une liste exhaustive. Il peut y avoir de nombreuses autres variantes. J'ai simplifié à l'extrême le concept pour en faciliter la compréhension.
 Les opérateurs de mutation diffèrent également selon les langages de programmation, la conception et les spécifications de l'application.
 S'il y a des mutants vivants à la fin du test. Cela signifie soit qu'il s'agit d'un mutant invalide (comme 5, 7 et 8), soit que l'ensemble de données était inadéquat. Si c'est le dernier, revenez en arrière et changez-le.
 Le test de mutation est une méthode de test structurel, en boîte blanche et unitaire. Il utilise l'injection de fautes ou l'ensemencement de fautes pour générer ses mutants.
 Il y a de nombreuses unités cadres de test et des outils qui facilitent les tests de mutation automatiques. Certains d'entre eux sont: Jester pour JUnit.
 Pester pour Python
 MuClipse pour Eclipse, etc.
 
 
 
 Pensez-vous, si cela demande autant d'efforts, que va-t-il se passer lorsque je devrai tester de grands échantillons de code?
  Les tests de mutation reposent sur deux choses: 
questions et réponses entretien sélénium pdf
   Hypothèse de programmeur compétent : Si un programmeur est assez compétent pour écrire et tester un petit morceau de code, il sera également doué pour écrire des programmes plus volumineux.
  Effet de couplage Hypothèse: Si 2 unités sont combinées pour former un programme et que chacune est bonne en soi, alors la combinaison sera également bonne.
 
 Alors, il se concentre sur la plus petite unité de code et met sa confiance dans la compétence du programmeur pour adapter les tests de mutation à des programmes plus importants. 
 Conclusion
 Ce didacticiel a couvert la définition, les types et les étapes des tests de mutation pour effectuer ces tests en détail avec des exemples. Nous espérons que vous avez apprécié la lecture et l'apprentissage de cette technique de test intéressante: le test de mutation.
  A propos de l'auteur: Cet article est écrit par Swati S., membre de l'équipe STH.
   Veuillez partager vos commentaires, questions et réflexions ci-dessous.  
  lecture recommandée
    Tutoriel sur les tests structurels - Qu'est-ce que les tests structurels  
  Qu'est-ce que la technique de test basée sur les défauts?  
  Qu'est-ce que la technique de test orthogonal Array (OATS)?  
  Une approche simple pour les tests de bases de données XML  
  Test de charge avec les didacticiels HP LoadRunner  
  Tutoriel de test de volume: exemples et outils de test de volume  
  Test fonctionnel vs test non fonctionnel  
  Tutoriel de test par paires ou de test toutes paires avec outils et exemples