El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Pruebas y Depuración

Siguiente ►
►

En este módulo, aprenderemos cómo realizar pruebas y depuración en Haskell. La capacidad de probar y depurar código es esencial para garantizar que nuestras aplicaciones funcionen correctamente y sean mantenibles. Cubriremos las siguientes secciones:

  1. Introducción a las Pruebas en Haskell
  2. Pruebas Unitarias con HUnit
  3. Pruebas de Propiedades con QuickCheck
  4. Depuración en Haskell
  5. Ejercicios Prácticos

Introducción a las Pruebas en Haskell

Las pruebas son una parte crucial del desarrollo de software. En Haskell, existen varias bibliotecas que nos ayudan a escribir y ejecutar pruebas. Las dos más populares son:

  • HUnit: Para pruebas unitarias.
  • QuickCheck: Para pruebas de propiedades.

¿Por qué son importantes las pruebas?

  • Verificación de Correctitud: Aseguran que el código hace lo que se espera.
  • Refactorización Segura: Permiten cambiar el código con confianza, sabiendo que las pruebas detectarán cualquier error introducido.
  • Documentación: Las pruebas pueden servir como documentación adicional sobre cómo se espera que funcione el código.

Pruebas Unitarias con HUnit

HUnit es una biblioteca para realizar pruebas unitarias en Haskell. Permite definir pruebas individuales y agruparlas en suites de pruebas.

Instalación de HUnit

Para instalar HUnit, puedes usar cabal o stack:

cabal install HUnit

o

stack add HUnit

Ejemplo de Prueba Unitaria

Supongamos que tenemos una función suma que suma dos números:

-- Archivo: Suma.hs
module Suma (suma) where

suma :: Int -> Int -> Int
suma x y = x + y

Podemos escribir una prueba unitaria para esta función usando HUnit:

-- Archivo: TestSuma.hs
import Test.HUnit
import Suma (suma)

testSuma :: Test
testSuma = TestCase (assertEqual "para (suma 1 2)," 3 (suma 1 2))

main :: IO Counts
main = runTestTT testSuma

Para ejecutar la prueba, simplemente compila y ejecuta el archivo TestSuma.hs:

runhaskell TestSuma.hs

Explicación del Código

  • TestCase define una prueba individual.
  • assertEqual verifica que el resultado de suma 1 2 sea 3.
  • runTestTT ejecuta la prueba y muestra los resultados.

Pruebas de Propiedades con QuickCheck

QuickCheck es una biblioteca para realizar pruebas de propiedades. En lugar de probar casos específicos, QuickCheck genera automáticamente casos de prueba basados en propiedades que definimos.

Instalación de QuickCheck

Para instalar QuickCheck, puedes usar cabal o stack:

cabal install QuickCheck

o

stack add QuickCheck

Ejemplo de Prueba de Propiedades

Supongamos que queremos probar que la suma es conmutativa:

-- Archivo: TestSumaProp.hs
import Test.QuickCheck
import Suma (suma)

prop_sumaConmutativa :: Int -> Int -> Bool
prop_sumaConmutativa x y = suma x y == suma y x

main :: IO ()
main = quickCheck prop_sumaConmutativa

Para ejecutar la prueba, simplemente compila y ejecuta el archivo TestSumaProp.hs:

runhaskell TestSumaProp.hs

Explicación del Código

  • prop_sumaConmutativa define una propiedad que debe cumplirse: suma x y debe ser igual a suma y x.
  • quickCheck ejecuta la prueba generando múltiples casos de prueba automáticamente.

Depuración en Haskell

La depuración es el proceso de encontrar y corregir errores en el código. Haskell ofrece varias herramientas para facilitar este proceso.

Uso de Debug.Trace

La biblioteca Debug.Trace permite insertar mensajes de depuración en el código.

import Debug.Trace

suma :: Int -> Int -> Int
suma x y = trace ("suma " ++ show x ++ " " ++ show y) (x + y)

GHCi para Depuración

GHCi, el intérprete interactivo de Haskell, es una herramienta poderosa para depurar código. Puedes cargar módulos, evaluar expresiones y examinar el estado del programa.

ghci Suma.hs

Dentro de GHCi, puedes evaluar expresiones y ver resultados:

*Main> suma 1 2
suma 1 2
3

Ejercicios Prácticos

Ejercicio 1: Prueba Unitaria

Escribe una prueba unitaria para una función multiplica que multiplica dos números.

-- Archivo: Multiplica.hs
module Multiplica (multiplica) where

multiplica :: Int -> Int -> Int
multiplica x y = x * y

Ejercicio 2: Prueba de Propiedades

Escribe una prueba de propiedades para verificar que la multiplicación es conmutativa.

-- Archivo: TestMultiplicaProp.hs
import Test.QuickCheck
import Multiplica (multiplica)

prop_multiplicaConmutativa :: Int -> Int -> Bool
prop_multiplicaConmutativa x y = multiplica x y == multiplica y x

main :: IO ()
main = quickCheck prop_multiplicaConmutativa

Ejercicio 3: Depuración

Modifica la función multiplica para incluir mensajes de depuración usando Debug.Trace.

import Debug.Trace

multiplica :: Int -> Int -> Int
multiplica x y = trace ("multiplica " ++ show x ++ " " ++ show y) (x * y)

Conclusión

En esta sección, hemos aprendido cómo realizar pruebas y depuración en Haskell utilizando HUnit y QuickCheck para pruebas unitarias y de propiedades, respectivamente. También hemos explorado cómo usar Debug.Trace y GHCi para depurar código. Estas herramientas y técnicas son esenciales para escribir código Haskell robusto y mantenible.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados