Workflow de test Haskell

Question

Je viens de commencer une nouvelle Haskell projet et je voulais un bon test de flux de travail depuis le début. Il semble que Haskell a beaucoup d'excellents unique et des outils de test et de nombreuses façons différentes de les intégrer.

J'ai regardé dans:

• HUnit
• QuickCheck
• benchpress
• HPC
• la complexité

Qui tous semblent très bien fonctionner dans leurs domaines, mais je suis à la recherche d'une approche globale de la tester et je me demandais ce qui a bien fonctionné pour d'autres personnes.

Answer 1

L'obtention de tests unitaires, de la couverture de code, et des critères de droite est la plupart du temps de choisir les bons outils.

• test-cadre offre un one-stop-shop pour exécuter tous vos HUnit cas de test et QuickCheck toutes les propriétés d'un harnais.
• La couverture de Code est intégré dans GHC dans la forme de la CPS de l'outil.
• Critère donne une assez grande analyse comparative des machines

Je vais utiliser comme un exemple, un paquet que je viens de commencer l'activation de l'unité de test, la couverture du code, et de repères:

http://github.com/ekmett/speculation

Vous pouvez intégrer vos tests et de benchmarks directement dans votre cabale fichier par l'ajout de sections pour eux, et de les masquer derrière des drapeaux afin de ne pas faire en sorte que tous les utilisateurs de votre bibliothèque pour avoir accès à (et que vous voulez utiliser pour eux-mêmes) la version exacte des outils de test que vous avez choisi.

http://github.com/ekmett/speculation/blob/master/speculation.cabal

Ensuite, vous pouvez dire cabale sur la façon d'exécuter des suites de tests. Comme cabale test n'existe pas encore-nous avons un étudiant qui travaille sur elle pour l'été de cette année de code! -- le meilleur mécanisme que nous avons est Ici est de savoir comment utiliser la cabale de l'utilisateur mécanisme de crochet. Cela signifie que le passage à une "Coutume" de construire avec de la cabale et de la configuration d'un testHook. Un exemple de testHook qui exécute un programme de test écrit avec test-cadre, et applique ensuite hpc de profil peut être trouvé ici:

http://github.com/ekmett/speculation/blob/master/Setup.lhs

Et puis vous pouvez utiliser le test-cadre pour s'emmitoufler QuickCheck et HUnit tests en un seul programme:

http://github.com/ekmett/speculation/blob/master/Test.hs

La cabale fichier, il est prudent de tourner sur fhpc pour permettre la couverture de code de test, puis les testHook dans le programme d'Installation.lhs manuellement fonctionne hpc et écrit le résultat dans votre dist dir.

Pour l'analyse comparative, l'histoire est un peu plus manuel, il n'y a pas de "cabale de référence" option. Vous pourriez fil de tes repères dans votre test de crochet, mais je tiens à les exécuter à la main, car le Critère a de nombreux rapports graphiques options. Vous pouvez ajouter des repères de la cabale fichier comme indiqué ci-dessus, leur donner de la compilation séparée des drapeaux, les masquer derrière une cabale drapeau, puis utiliser le Critère de faire tout le levage lourd:

http://github.com/ekmett/speculation/blob/master/Benchmark.hs

Vous pouvez ensuite exécuter vos repères à partir de la ligne de commande et d'obtenir le pop-up de KDE, windows avec les résultats d'un benchmark, etc.

Depuis, dans la pratique, vous vivez dans la cabale, de toute façon, pendant le développement du code Haskell, il fait beaucoup de jeu, afin d'intégrer vos outils avec elle.

Edit: Cabale test à l'appui maintenant, n'existe pas. Voir http://www.haskell.org/cabal/release/cabal-latest/doc/users-guide/developing-packages.html#test-suites

Answer 2

L'approche est avocat à la GEPLUIE ch 11 et dans XMonad est d'environ:

• L'état de toutes les propriétés du système dans QuickCheck
• Montrer la couverture de test avec le HPC.
• Confirmer espace de comportement avec des tas de profilage.
• Confirmer thread/parallèle comportement avec ThreadScope.
• Confirmer microbenchmark comportement avec Critère.

Une fois que vos grands invariants sont établis par QuickCheck, vous pouvez commencer à refactoring, l'évolution de ces tests dans le type d'invariants.

Pratiques pour soutenir vos efforts:

• Exécuter une procédure simplifiée QuickCheck de régression à chaque livraison.
• Publier HPC informations sur la couverture.

Answer 3

Le test-cadre package est vraiment génial. Vous pouvez facilement intégrer HUnit et QuickCheck tests, et d'obtenir les fichiers exécutables exécuter spécifié suites seulement, en fonction des options de ligne de commande, avec de multiples cibles de sortie.

Les tests et le profilage sont différents des bêtes. Pour le profilage j'avais crée un exécutable qui souligne juste la partie que vous voulez de profil, et juste en regardant attentivement les résultats de profilage construit et exécute (avec -prof-automatique-tout pour la compilation et +RTS-p pour une exécution drapeau).

Answer 4

Pour les tests, je me fie aux propriétés HUnit et QuickCheck et utilise le framework de test Haskell pour collecter automatiquement tous les tests unitaires et toutes les propriétés QuickCheck.

Disclaimer: Je suis le développeur principal du framework de test Haskell.