El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Introducció a les Assertions

Següent ►
►

Les assertions són una part fonamental de JUnit i de qualsevol framework de testing. Ens permeten verificar que el codi que estem provant es comporta com esperem. En aquesta secció, aprendrem què són les assertions, per què són importants i com utilitzar-les en els nostres tests de JUnit.

Què són les Assertions?

Les assertions són expressions que avaluen una condició i, si aquesta condició no es compleix, el test falla. Són essencials per validar el comportament del codi i assegurar-nos que els resultats són els esperats.

Per què són importants les Assertions?

  • Verificació Automàtica: Les assertions permeten verificar automàticament que el codi funciona correctament sense necessitat d'intervenció manual.
  • Documentació: Les assertions actuen com a documentació viva del comportament esperat del codi.
  • Detecció de Errors: Faciliten la detecció de errors en el codi, ja que els tests fallaran si alguna cosa no funciona com s'espera.

Tipus d'Assertions a JUnit

JUnit proporciona diverses assertions que podem utilitzar per validar diferents tipus de condicions. A continuació, es mostren algunes de les assertions més comunes:

Assertion Descripció
assertEquals(expected, actual) Verifica que dos valors són iguals.
assertNotEquals(unexpected, actual) Verifica que dos valors no són iguals.
assertTrue(condition) Verifica que una condició és certa.
assertFalse(condition) Verifica que una condició és falsa.
assertNull(object) Verifica que un objecte és null.
assertNotNull(object) Verifica que un objecte no és null.
assertArrayEquals(expectedArray, actualArray) Verifica que dos arrays són iguals.
assertSame(expected, actual) Verifica que dos referències apunten al mateix objecte.
assertNotSame(unexpected, actual) Verifica que dos referències no apunten al mateix objecte.
fail() Falla el test de manera intencionada.

Exemple Pràctic

Vegem un exemple pràctic d'ús de les assertions en un test de JUnit. Suposem que tenim una classe Calculator amb un mètode add que suma dos nombres.

Codi de la Classe Calculator

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

Codi del Test amb Assertions

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class CalculatorTest {

    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        
        // Utilitzant assertions per verificar el resultat
        assertEquals(5, result, "El resultat hauria de ser 5");
        assertNotEquals(4, result, "El resultat no hauria de ser 4");
        assertTrue(result > 0, "El resultat hauria de ser positiu");
        assertFalse(result < 0, "El resultat no hauria de ser negatiu");
    }
}

Explicació del Codi

  1. Importació de Assertions: Importem les assertions de JUnit utilitzant import static org.junit.jupiter.api.Assertions.*;.
  2. Creació del Test: Definim un test amb l'anotació @Test.
  3. Instanciació de la Classe: Creem una instància de la classe Calculator.
  4. Execució del Mètode: Executem el mètode add amb els valors 2 i 3.
  5. Utilització d'Assertions: Utilitzem diverses assertions per verificar que el resultat és correcte:
    • assertEquals(5, result, "El resultat hauria de ser 5"): Verifica que el resultat és 5.
    • assertNotEquals(4, result, "El resultat no hauria de ser 4"): Verifica que el resultat no és 4.
    • assertTrue(result > 0, "El resultat hauria de ser positiu"): Verifica que el resultat és positiu.
    • assertFalse(result < 0, "El resultat no hauria de ser negatiu"): Verifica que el resultat no és negatiu.

Exercici Pràctic

Exercici

Crea una classe StringUtils amb un mètode isPalindrome que comprovi si una cadena és un palíndrom (es llegeix igual d'esquerra a dreta que de dreta a esquerra). Escriu un test de JUnit per verificar el comportament d'aquest mètode utilitzant diverses assertions.

Solució

Codi de la Classe StringUtils

public class StringUtils {
    public boolean isPalindrome(String str) {
        if (str == null) {
            return false;
        }
        String reversed = new StringBuilder(str).reverse().toString();
        return str.equals(reversed);
    }
}

Codi del Test amb Assertions

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class StringUtilsTest {

    @Test
    public void testIsPalindrome() {
        StringUtils stringUtils = new StringUtils();
        
        // Casos de prova
        assertTrue(stringUtils.isPalindrome("madam"), "madam hauria de ser un palíndrom");
        assertFalse(stringUtils.isPalindrome("hello"), "hello no hauria de ser un palíndrom");
        assertTrue(stringUtils.isPalindrome("racecar"), "racecar hauria de ser un palíndrom");
        assertFalse(stringUtils.isPalindrome(null), "null no hauria de ser un palíndrom");
        assertTrue(stringUtils.isPalindrome(""), "Una cadena buida hauria de ser un palíndrom");
    }
}

Explicació del Codi

  1. Creació de la Classe StringUtils: Definim la classe StringUtils amb el mètode isPalindrome.
  2. Creació del Test: Definim un test amb l'anotació @Test.
  3. Instanciació de la Classe: Creem una instància de la classe StringUtils.
  4. Utilització d'Assertions: Utilitzem diverses assertions per verificar el comportament del mètode isPalindrome amb diferents casos de prova:
    • assertTrue(stringUtils.isPalindrome("madam"), "madam hauria de ser un palíndrom"): Verifica que "madam" és un palíndrom.
    • assertFalse(stringUtils.isPalindrome("hello"), "hello no hauria de ser un palíndrom"): Verifica que "hello" no és un palíndrom.
    • assertTrue(stringUtils.isPalindrome("racecar"), "racecar hauria de ser un palíndrom"): Verifica que "racecar" és un palíndrom.
    • assertFalse(stringUtils.isPalindrome(null), "null no hauria de ser un palíndrom"): Verifica que null no és un palíndrom.
    • assertTrue(stringUtils.isPalindrome(""), "Una cadena buida hauria de ser un palíndrom"): Verifica que una cadena buida és un palíndrom.

Conclusió

En aquesta secció, hem après què són les assertions, per què són importants i com utilitzar-les en els nostres tests de JUnit. Les assertions ens permeten verificar automàticament el comportament del nostre codi i detectar errors de manera eficient. En la següent secció, explorarem les assertions comunes en més detall.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats