Flujo de trabajo de prueba de Haskell

Question

Acabo de comenzar un nuevo proyecto de Haskell y quería establecer un buen flujo de trabajo de prueba desde el principio. Parece que Haskell tiene muchas herramientas de prueba excelentes y únicas y muchas formas diferentes de integrarlas.

He mirado en:

• HUnit
• QuickCheck
• benchpress
• HPC
• complexity

cual todos parecen trabajan muy bien en sus dominios, pero estoy buscando un enfoque integral para las pruebas y me preguntaba qué ha funcionado bien para otras personas.

Answer 1

Las pruebas de unidades, la cobertura de códigos y los parámetros de referencia son principalmente para elegir las herramientas adecuadas.

• prueba de marco proporciona una ventanilla única para ejecutar todas sus HUnit casos de prueba y QuickCheck todas las propiedades de un arnés.
• La cobertura del código está incorporada en GHC en forma de la herramienta HPC.
• Criterio ofrece algunos bastante grandes máquinas evaluación comparativa

voy a utilizar como ejemplo la ejecución de un paquete que acabo de empezar permitiendo con pruebas unitarias, cobertura de código, y los puntos de referencia:

http://github.com/ekmett/speculation

Puede integrar sus pruebas y puntos de referencia directamente en su archivo cabal agregando secciones para ellos y enmascararlos detrás de indicadores para que no lo hagan de modo que todos los usuarios de su biblioteca tengan acceso (y deseen usarlo por sí mismos)) la versión exacta de las herramientas de prueba tú has elegido.

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

Entonces, se puede decir cabal acerca de cómo ejecutar su serie de pruebas. Como la prueba cabal todavía no existe, ¡tenemos un estudiante trabajando en ella para el código de verano de este año! - el mejor mecanismo que tenemos es Aquí se explica cómo usar el mecanismo de gancho de usuario de cabal. Esto significa cambiar a una compilación 'Custom' con cabal y configurar un testHook. Un ejemplo de un testHook que se ejecuta un programa de prueba escrita con prueba de marco, y luego se aplica HPC al perfil que se puede encontrar aquí:

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

Y a continuación, puede utilizar la prueba-marco para abrigarse QuickCheck y HUnit pruebas en un solo programa:

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

el archivo Cabal no tiene cuidado para encender -fhpc que permitan la comprobación de cobertura de código, y luego el testHook en Setup.lhs se ejecuta manualmente HPC y escribe su salida en su dist dir.

Para la evaluación comparativa, la historia es un poco más manual, no existe la opción de "punto de referencia cabal". Puede conectar sus puntos de referencia en su gancho de prueba, pero me gusta ejecutarlos a mano, ya que Criterion tiene tantas opciones de informes gráficos. Puede añadir sus puntos de referencia en el fichero de Cabal como se muestra arriba, darles banderas de compilación independiente, ocultarlos detrás de una bandera de Cabal, y luego usar el criterio de hacer todo el trabajo pesado:

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

continuación, puede ejecutar sus puntos de referencia desde la línea de comando y obtener ventanas emergentes de KDE con resultados de referencia, etc.

Dado que en la práctica usted vive en cabal de todos modos mientras desarrolla el código Haskell, tiene mucho sentido integrar su cadena de herramientas con ella .

Editar: El soporte de prueba Cabal ya existe. Consulte http://www.haskell.org/cabal/release/cabal-latest/doc/users-guide/developing-packages.html#test-suites

Answer 2

El enfoque es defensor en RWH ch 11 y en XMonad es aproximadamente:

• Estado todas las propiedades del sistema en QuickCheck
• Muestra test coverage con HPC.
• Confirme el comportamiento del espacio con heap profiling.
• Confirme el comportamiento de hilo/paralelo con ThreadScope.
• Confirme el comportamiento de microbenchmark con Criterion.

Una vez que las principales invariantes se establecen a través de QuickCheck, puede comenzar la refactorización, moviendo esas pruebas al tipo invariantes.

Prácticas para apoyar sus esfuerzos:

• Ejecutar una regresión QuickCheck simplificada en cada commit.
• Publicación de los detalles de la cobertura de HPC.

Answer 3

El test-framework package es realmente increíble. Puede integrar fácilmente las pruebas HUnit y QuickCheck, y obtener ejecutables que solo ejecutan suites especificadas, basadas en indicadores de línea de comando, con múltiples objetivos de salida.

Sin embargo, las pruebas y los perfiles son bestias diferentes. Para crear perfiles, configuré un archivo ejecutable independiente que enfatiza solo la sección que desea perfilar, y solo miro con cuidado los resultados de creación de perfiles y ejecuciones (con -prof-auto-all para compilación y + RTS -p para un tiempo de ejecución bandera).

Answer 4

Para realizar pruebas, confío en las propiedades HUnit y QuickCheck y uso el Haskell Test Framework para recopilar todas las pruebas unitarias y todas las propiedades de QuickCheck automáticamente.

Descargo de responsabilidad: soy el principal desarrollador de Haskell Test Framework.