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

JUnit

Següent ►
►

JUnit és un dels frameworks de proves més populars per a Java. Permet als desenvolupadors escriure i executar proves unitàries de manera senzilla i eficient. Les proves unitàries són essencials per assegurar que el codi funcioni correctament i per detectar errors de manera primerenca en el cicle de desenvolupament.

Continguts

  1. Introducció a JUnit
  2. Configuració de JUnit
  3. Estructura d'una Prova JUnit
  4. Anotacions de JUnit
  5. Assert Statements
  6. Proves Parametritzades
  7. Exercicis Pràctics
  8. Conclusió

Introducció a JUnit

JUnit és un framework de proves unitàries per a Java que permet als desenvolupadors escriure i executar proves de manera senzilla. Les proves unitàries són petites proves que verifiquen el comportament d'una unitat de codi, com ara un mètode o una classe.

Beneficis de JUnit

  • Detecció Primerenca d'Errors: Permet detectar errors en el codi de manera primerenca.
  • Refactorització Segura: Facilita la refactorització del codi amb confiança.
  • Documentació del Codi: Les proves poden servir com a documentació del comportament esperat del codi.
  • Automatització de Proves: Permet l'automatització de proves, millorant l'eficiència del desenvolupament.

Configuració de JUnit

Afegir JUnit al Projecte

Per utilitzar JUnit, primer cal afegir la dependència de JUnit al projecte. Si utilitzes Maven, pots afegir la següent dependència al teu pom.xml:

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

Si utilitzes Gradle, afegeix la següent línia al teu build.gradle:

testImplementation 'junit:junit:4.13.2'

Estructura d'una Prova JUnit

Una prova JUnit típica consta de les següents parts:

  1. Classe de Prova: Una classe que conté els mètodes de prova.
  2. Mètodes de Prova: Mètodes que contenen el codi de prova.
  3. Anotacions: Anotacions que indiquen a JUnit com executar els mètodes de prova.

Exemple Bàsic

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class CalculadoraTest {

    @Test
    public void testSuma() {
        Calculadora calc = new Calculadora();
        int resultat = calc.suma(2, 3);
        assertEquals(5, resultat);
    }
}

En aquest exemple, CalculadoraTest és la classe de prova, testSuma és el mètode de prova, i @Test és l'anotació que indica a JUnit que aquest mètode és una prova.

Anotacions de JUnit

JUnit proporciona diverses anotacions per configurar i executar proves:

  • @Test: Indica que un mètode és una prova.
  • @Before: S'executa abans de cada mètode de prova.
  • @After: S'executa després de cada mètode de prova.
  • @BeforeClass: S'executa una vegada abans de tots els mètodes de prova en la classe.
  • @AfterClass: S'executa una vegada després de tots els mètodes de prova en la classe.
  • @Ignore: Indica que un mètode de prova ha de ser ignorat.

Exemple d'Ús d'Anotacions

import org.junit.Before;
import org.junit.After;
import org.junit.BeforeClass;
import org.junit.AfterClass;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class CalculadoraTest {

    private Calculadora calc;

    @BeforeClass
    public static void setupClass() {
        System.out.println("Abans de totes les proves");
    }

    @AfterClass
    public static void teardownClass() {
        System.out.println("Després de totes les proves");
    }

    @Before
    public void setup() {
        calc = new Calculadora();
    }

    @After
    public void teardown() {
        calc = null;
    }

    @Test
    public void testSuma() {
        int resultat = calc.suma(2, 3);
        assertEquals(5, resultat);
    }
}

Assert Statements

Les assert statements s'utilitzen per verificar que els resultats de les proves són els esperats. JUnit proporciona diverses assert statements, com ara:

  • assertEquals(expected, actual): Verifica que dos valors 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.

Exemple d'Ús d'Assert Statements

import org.junit.Test;
import static org.junit.Assert.*;

public class CalculadoraTest {

    @Test
    public void testResta() {
        Calculadora calc = new Calculadora();
        int resultat = calc.resta(5, 3);
        assertEquals(2, resultat);
    }

    @Test
    public void testMultiplicacio() {
        Calculadora calc = new Calculadora();
        int resultat = calc.multiplicacio(2, 3);
        assertTrue(resultat == 6);
    }
}

Proves Parametritzades

JUnit permet escriure proves parametritzades, que són proves que s'executen diverses vegades amb diferents conjunts de dades.

Exemple de Prova Parametritzada

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.Arrays;
import java.util.Collection;
import static org.junit.Assert.assertEquals;

@RunWith(Parameterized.class)
public class CalculadoraParamTest {

    private int input1;
    private int input2;
    private int expected;

    public CalculadoraParamTest(int input1, int input2, int expected) {
        this.input1 = input1;
        this.input2 = input2;
        this.expected = expected;
    }

    @Parameterized.Parameters
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {
            { 1, 1, 2 },
            { 2, 3, 5 },
            { 3, 3, 6 }
        });
    }

    @Test
    public void testSuma() {
        Calculadora calc = new Calculadora();
        assertEquals(expected, calc.suma(input1, input2));
    }
}

Exercicis Pràctics

Exercici 1: Escriure Proves per a una Classe Calculadora

  1. Crea una classe Calculadora amb els mètodes suma, resta, multiplicacio i divisio.
  2. Escriu una classe de prova CalculadoraTest que contingui proves per a cadascun dels mètodes de la classe Calculadora.

Solució

public class Calculadora {

    public int suma(int a, int b) {
        return a + b;
    }

    public int resta(int a, int b) {
        return a - b;
    }

    public int multiplicacio(int a, int b) {
        return a * b;
    }

    public int divisio(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("El divisor no pot ser zero");
        }
        return a / b;
    }
}
import org.junit.Test;
import static org.junit.Assert.*;

public class CalculadoraTest {

    @Test
    public void testSuma() {
        Calculadora calc = new Calculadora();
        assertEquals(5, calc.suma(2, 3));
    }

    @Test
    public void testResta() {
        Calculadora calc = new Calculadora();
        assertEquals(2, calc.resta(5, 3));
    }

    @Test
    public void testMultiplicacio() {
        Calculadora calc = new Calculadora();
        assertEquals(6, calc.multiplicacio(2, 3));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDivisioPerZero() {
        Calculadora calc = new Calculadora();
        calc.divisio(5, 0);
    }

    @Test
    public void testDivisio() {
        Calculadora calc = new Calculadora();
        assertEquals(2, calc.divisio(6, 3));
    }
}

Conclusió

JUnit és una eina poderosa per a la realització de proves unitàries en Java. Permet als desenvolupadors escriure proves de manera senzilla i eficient, millorant la qualitat del codi i facilitant la detecció primerenca d'errors. En aquest tema, hem après a configurar JUnit, escriure proves bàsiques, utilitzar anotacions i assert statements, i crear proves parametritzades. Amb aquestes habilitats, estaràs preparat per assegurar la qualitat del teu codi Java mitjançant proves unitàries.

◄ Anterior
◄
Següent ►
►

Curs de Programació en Java

Mòdul 1: Introducció a Java

Mòdul 2: Flux de Control

Mòdul 3: Programació Orientada a Objectes

Mòdul 4: Programació Orientada a Objectes Avançada

Mòdul 5: Estructures de Dades i Col·leccions

Mòdul 6: Gestió d'Excepcions

Mòdul 7: Entrada/Sortida de Fitxers

Mòdul 8: Multithreading i Concurrència

Mòdul 9: Xarxes

Mòdul 10: Temes Avançats

Mòdul 11: Frameworks i Llibreries de Java

Mòdul 12: Construcció d'Aplicacions del Món Real

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats