IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langages de programmation Discussion :

Tests de mutation: contrôle de qualité des tests unitaires: des précisions ?


Sujet :

Langages de programmation

  1. #1
    Membre averti

    Homme Profil pro
    Développeur informatique
    Inscrit en
    mars 2007
    Messages
    186
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : mars 2007
    Messages : 186
    Points : 411
    Points
    411
    Par défaut Tests de mutation: contrôle de qualité des tests unitaires: des précisions ?
    Bonjour,
    Je vient de lire l'article de Jean-François Lépine sur son logiciel MutaTesting de contrôle de qualité des tests unitaires.
    Je m'intéresse à l'idée de triturer des tests unitaire dynamiquement, donc sans avoir a y effectuer de changement, pour assurer le suivis de leur qualité. Mais j'aimerasi mieux comprendre la manière dont cela fonctionne. Citation:
    C’est tout. A partir de là, MutaTesting va procéder à un certain nombre de processus :

    • les tests vont être lancés une première fois
    • chaque suite de test va être isolée, puis relancée pour déterminer quelles sources PHP elle permet de tester
    • le code source est converti en tokens, puis chaque token transformable est transformé en mutant
    • chaque suite de test va être relancée sur chaque mutation de code



    Bien entendu, votre code source n’est jamais modifié. En réalité, l’outil joue avec un StreamWrapper spécifique pour le flux de fichier standard (file://) pour substituer la mutation à votre code originel.

    Voici quelques exemples de bugs qui peuvent être introduits :

    • remplacer un test d’égalité (« == ») par un test de non-égalite ( » != « )
    • remplacer » true » par « false »
    • supprimer un bloc » else «
    Je n'es pas bien compris, que va en fait modifer la mutation au niveau des test unitaire ?

  2. #2
    Expert confirmé Avatar de DonQuiche
    Inscrit en
    septembre 2010
    Messages
    2 741
    Détails du profil
    Informations forums :
    Inscription : septembre 2010
    Messages : 2 741
    Points : 5 459
    Points
    5 459
    Par défaut
    Cet outil va introduire des bogues dans ton code. Non pas dans les tests mais dans le code testé. Non pas dans les sources physiques elles-mêmes mais dans la représentation en mémoire du code (le "bytecode" si le terme s'applique à l'interpréteur php).

    Il s'agit de vérifier si tes tests détectent ces bogues.

  3. #3
    Membre averti

    Homme Profil pro
    Développeur informatique
    Inscrit en
    mars 2007
    Messages
    186
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : mars 2007
    Messages : 186
    Points : 411
    Points
    411
    Par défaut
    D'accord, c'est le code testé qui se comporte différemment et on regarde si les tests "détectent" les bogues induis. Mais alors comment un test unitaire peut-il correctement tester une logique de code qui peut changer ? Auriez-vous un exemple ?
    Prenons cet algorithme:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    fonction diviser(nombre_a_diviser, nombre_diviseur):
      si nombre_diviseur != 0:
        retourner nombre_a_diviser / nombre_diviseur
      sinon:
        lever erreur de type TestArithmétiqueException "Diviseur égal à 0"
    Testé par:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    assertEstEgal(diviser(10, 2), 5)
    assertEstEgal(diviser(100, 2), 50)
    assertLeveException(diviser(100, 0), TestArithmétiqueException)
    Si la mutation vient changer l'opérateur "!=" en "==" ligne 2, dans mes tests unitaires la ligne 1 et 2 vont échoué car une TestArithmétiqueException sera levé, quand la ligne 3 elle cherchera a attraper une exception de type TestArithmétiqueException mais échouera car l'exception levé sera d'un autre type.

    De quel manière ces tests devrait-ils être écrit pour détecter les bogues du aux mutations ?

  4. #4
    Expert confirmé Avatar de DonQuiche
    Inscrit en
    septembre 2010
    Messages
    2 741
    Détails du profil
    Informations forums :
    Inscription : septembre 2010
    Messages : 2 741
    Points : 5 459
    Points
    5 459
    Par défaut
    Citation Envoyé par buxbux Voir le message
    Si la mutation vient changer l'opérateur "!=" en "==" ligne 2, dans mes tests unitaires la ligne 1 et 2 vont échoué car une TestArithmétiqueException sera levé, quand la ligne 3 elle cherchera a attraper une exception de type TestArithmétiqueException mais échouera car l'exception levé sera d'un autre type.

    De quel manière ces tests devrait-ils être écrit pour détecter les bogues du aux mutations ?
    Ces tests sont très bien comme tels. Puisque ce n'est pas la bonne exception le test va échouer. Le fait qu'au moins un test se mette à échouer est la preuve que la batterie de tests est capable de mettre en évidence le bogue introduit. Donc qu'elle est d'une certaine qualité.

    Il ne faut pas chercher à rendre les tests résistants aux bogues introduits. Il faut au contraire créer des tests qui échoueront quand des bogues seront introduits !

  5. #5
    Membre averti

    Homme Profil pro
    Développeur informatique
    Inscrit en
    mars 2007
    Messages
    186
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : mars 2007
    Messages : 186
    Points : 411
    Points
    411
    Par défaut
    Il ne faut pas chercher à rendre les tests résistants aux bogues introduits. Il faut au contraire créer des tests qui échoueront quand des bogues seront introduits !
    Ca y est, tout prend son sens maintenant. Les test de mutations semblent être de tout intérêt ! D'autant que les bogues injectés sembles bien représenter des cas de figures récurrent avec des langages au typage faible.

    Merci pour cet éclairage !

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. faire des fakes pour des test, je suis perdu
    Par giova_fr dans le forum C#
    Réponses: 0
    Dernier message: 17/08/2013, 13h21
  2. afficher des images avec des tests
    Par stratocasters dans le forum JSF
    Réponses: 2
    Dernier message: 02/08/2010, 14h31
  3. Réponses: 5
    Dernier message: 29/09/2009, 13h26
  4. awk / cut : Comment copier des colonnes avec des tests
    Par drareg06 dans le forum Shell et commandes GNU
    Réponses: 2
    Dernier message: 16/07/2008, 12h49
  5. Réponses: 3
    Dernier message: 23/01/2007, 09h14

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo