En aquest tema, aprendrem com provar i depurar el codi Haskell. La prova i la depuració són parts essencials del desenvolupament de programari, ja que ens ajuden a assegurar-nos que el nostre codi funciona correctament i a identificar i corregir errors.
Contingut
Introducció a les Proves
Les proves són una manera de verificar que el nostre codi funciona com s'espera. Hi ha diversos tipus de proves, però en aquest tema ens centrarem en les proves unitàries i les proves de propietats.
Tipus de Proves
- Proves Unitàries: Verifiquen el funcionament correcte de funcions individuals.
- Proves de Propietats: Verifiquen que el codi compleix certes propietats generals.
Proves Unitàries amb HUnit
HUnit és una biblioteca de proves unitàries per a Haskell. Permet definir proves per a funcions individuals i verificar que els resultats siguin els esperats.
Instal·lació de HUnit
Per instal·lar HUnit, pots utilitzar cabal o stack:
o
Exemple de Prova Unitària
A continuació, es mostra un exemple de com definir i executar una prova unitària amb HUnit:
import Test.HUnit -- Funció a provar sumar :: Int -> Int -> Int sumar x y = x + y -- Prova unitària testSumar :: Test testSumar = TestCase (assertEqual "per sumar 1 i 2" 3 (sumar 1 2)) -- Executar les proves main :: IO Counts main = runTestTT testSumar
Explicació del Codi
import Test.HUnit: Importa la biblioteca HUnit.sumar: Defineix una funció simple que suma dos enters.testSumar: Defineix una prova unitària que verifica quesumar 1 2retorna3.main: Executa la prova unitària.
Proves de Propietats amb QuickCheck
QuickCheck és una altra biblioteca de proves per a Haskell que permet definir propietats que el codi ha de complir i genera casos de prova aleatoris per verificar aquestes propietats.
Instal·lació de QuickCheck
Per instal·lar QuickCheck, pots utilitzar cabal o stack:
o
Exemple de Prova de Propietats
A continuació, es mostra un exemple de com definir i executar una prova de propietats amb QuickCheck:
import Test.QuickCheck -- Propietat a provar prop_SumaCommutativa :: Int -> Int -> Bool prop_SumaCommutativa x y = sumar x y == sumar y x -- Executar les proves main :: IO () main = quickCheck prop_SumaCommutativa
Explicació del Codi
import Test.QuickCheck: Importa la biblioteca QuickCheck.prop_SumaCommutativa: Defineix una propietat que verifica que la suma és commutativa.main: Executa la prova de propietats.
Depuració amb GHCi
GHCi és el REPL de Haskell i també es pot utilitzar per a la depuració. A continuació, es mostren algunes tècniques de depuració amb GHCi.
Utilització de :trace i :history
GHCi proporciona comandes com :trace i :history per ajudar a depurar el codi.
-- Exemple de funció amb error dividir :: Int -> Int -> Int dividir _ 0 = error "Divisió per zero" dividir x y = x `div` y -- Carregar el fitxer en GHCi -- :l fitxer.hs -- Traçar l'execució -- :trace dividir 10 0 -- Veure l'historial -- :history
Explicació del Codi
dividir: Defineix una funció que divideix dos enters, però genera un error si el divisor és zero.:trace: Traça l'execució de la funció.:history: Mostra l'historial de l'execució.
Exercicis Pràctics
Exercici 1: Prova Unitària
Defineix una funció multiplicar que multiplica dos enters i escriu una prova unitària per verificar que multiplicar 3 4 retorna 12.
Solució
import Test.HUnit -- Funció a provar multiplicar :: Int -> Int -> Int multiplicar x y = x * y -- Prova unitària testMultiplicar :: Test testMultiplicar = TestCase (assertEqual "per multiplicar 3 i 4" 12 (multiplicar 3 4)) -- Executar les proves main :: IO Counts main = runTestTT testMultiplicar
Exercici 2: Prova de Propietats
Defineix una propietat que verifica que la multiplicació és commutativa i escriu una prova de propietats per a aquesta propietat.
Solució
import Test.QuickCheck -- Propietat a provar prop_MultiplicacioCommutativa :: Int -> Int -> Bool prop_MultiplicacioCommutativa x y = multiplicar x y == multiplicar y x -- Executar les proves main :: IO () main = quickCheck prop_MultiplicacioCommutativa
Conclusió
En aquest tema, hem après com provar i depurar el codi Haskell utilitzant HUnit per a proves unitàries, QuickCheck per a proves de propietats i GHCi per a la depuració. Les proves i la depuració són eines essencials per assegurar-nos que el nostre codi funciona correctament i per identificar i corregir errors.