@Test
void laMultaEsLimitaAlMaximConfigurat() {
    Prestec prestec = prestecAmbRetard(200);   // 200 dies x 0,50 EUR = 100 EUR
    assertThat(calculadora.calcular(prestec)).isEqualByComparingTo("20.00");
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.2</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>3.25.3</version>
    <scope>test</scope>
</dependency>

src/
├── main/java/com/nexussoftware/bibliotech/     <- codi de produccio
├── main/resources/                             <- application.yml
├── test/java/com/nexussoftware/bibliotech/     <- LES PROVES, mateix paquet
└── test/resources/                             <- application-test.yml, fitxers de prova

package com.nexussoftware.bibliotech.servei;

import java.math.BigDecimal;
import java.time.*;
import java.time.temporal.ChronoUnit;
import org.springframework.stereotype.Service;

@Service
public class CalculadoraMultes {

    private final PropietatsBiblioTech propietats;
    private final Clock rellotge;

    public CalculadoraMultes(PropietatsBiblioTech propietats, Clock rellotge) {
        this.propietats = propietats;
        this.rellotge = rellotge;
    }

    public BigDecimal calcular(Prestec prestec) {
        if (prestec.getDataDevolucio().isPresent()) {
            return BigDecimal.ZERO;   // ja retornat: sense multa
        }
        LocalDate avui = LocalDate.now(rellotge);
        long diesRetard = ChronoUnit.DAYS.between(prestec.getDataVenciment(), avui);
        if (diesRetard <= 0) {
            return BigDecimal.ZERO;   // encara en termini
        }
        BigDecimal multa = propietats.multa().eurosPerDia()
                .multiply(BigDecimal.valueOf(diesRetard));
        return multa.min(propietats.multa().maxima());
    }
}

package com.nexussoftware.bibliotech.servei;

import static org.assertj.core.api.Assertions.assertThat;

import java.math.BigDecimal;
import java.time.*;
import org.junit.jupiter.api.Test;

class CalculadoraMultesTest {

    @Test
    void unPrestecAmbCincDiesDeRetardGeneraDosEurosCinquanta() {

        // PREPARAR: un rellotge FIX. "Avui" es sempre el 20 de marc de 2026.
        Clock rellotgeFix = Clock.fixed(
                Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));

        PropietatsBiblioTech propietats = propietatsDeProva(
                new BigDecimal("0.50"), new BigDecimal("20.00"));

        CalculadoraMultes calculadora = new CalculadoraMultes(propietats, rellotgeFix);

        // Vencia el 15 -> 5 dies de retard respecte al 20
        Prestec prestec = new Prestec(unLlibre(), unEmpleat(),
                LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 15));

        // ACTUAR
        BigDecimal multa = calculadora.calcular(prestec);

        // COMPROVAR
        assertThat(multa).isEqualByComparingTo("2.50");
    }
}

mvn test

[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS

@Test
void unEmpleatNoPotSuperarElLimitDePrestecs() {

    // PREPARAR (Arrange): muntar l'escenari
    Empleat marta = new Empleat("[email protected]", "Marta Ruiz");
    GestorPrestecs gestor = new GestorPrestecs(repositori, calculadora, avisos, propietats, rellotge);
    gestor.prestar("978-0000000001", marta.getCorreu());
    gestor.prestar("978-0000000002", marta.getCorreu());
    gestor.prestar("978-0000000003", marta.getCorreu());

    // ACTUAR (Act): UNA sola accio, la que s'esta provant
    ThrowingCallable quartPrestec =
            () -> gestor.prestar("978-0000000004", marta.getCorreu());

    // COMPROVAR (Assert): verificar el resultat
    assertThatThrownBy(quartPrestec)
            .isInstanceOf(LimitPrestecsException.class)
            .hasMessageContaining("[email protected]");
}

@DisplayName("Càlcul de multes per retard")
class CalculadoraMultesTest {

    @Test
    @DisplayName("Un préstec amb 5 dies de retard genera una multa de 2,50 €")
    void multaDeCincDies() { ... }

    @Test
    @DisplayName("La multa mai no supera el màxim configurat (20 €)")
    void multaLimitadaAlMaxim() { ... }
}

Càlcul de multes per retard
  ✔ Un préstec amb 5 dies de retard genera una multa de 2,50 €
  ✔ La multa mai no supera el màxim configurat (20 €)

assertEquals(3, gestor.comptarActius(marta),
             "Marta hauria de tenir 3 prestecs actius despres de prestar tres materials");

assertTrue(prestec.estaVencut(avui),
           () -> "El prestec vencia el " + prestec.getDataVenciment() + " i avui es " + avui);

@Test
void prestarUnMaterialSenseExemplarsLlancaExcepcio() {

    Material exhaurit = new Llibre("978-0000000003", "Refactoritzacio", 0, "M. Fowler");

    // assertThrows RETORNA l'excepcio: es pot inspeccionar
    SenseExemplarsException excepcio = assertThrows(
            SenseExemplarsException.class,
            () -> exhaurit.prestarUnExemplar());

    assertEquals("978-0000000003", excepcio.getIsbn());
    assertTrue(excepcio.getMessage().contains("978-0000000003"));
}

// MALAMENT: si NO llanca l'excepcio, la prova passa igualment
@Test
void malament() {
    try {
        exhaurit.prestarUnExemplar();
    } catch (SenseExemplarsException e) {
        assertEquals("978-0000000003", e.getIsbn());
    }
    // Si no es llanca res, no s'executa cap catch... i la prova es verda.
}

@Test
void unPrestecNouTeLesDadesCorrectes() {

    LocalDate avui = LocalDate.of(2026, 3, 1);
    Prestec prestec = new Prestec(unLlibre(), unEmpleat(), avui, 15);

    assertAll("dades del prestec acabat de crear",
            () -> assertEquals(avui, prestec.getDataPrestec()),
            () -> assertEquals(avui.plusDays(15), prestec.getDataVenciment()),
            () -> assertEquals(EstatPrestec.ACTIU, prestec.getEstat()),
            () -> assertTrue(prestec.getDataDevolucio().isEmpty()),
            () -> assertNotNull(prestec.getMaterial()));
}

// JUnit
assertEquals(3, prestecs.size());

org.opentest4j.AssertionFailedError: expected: <3> but was: <2>

// AssertJ
assertThat(prestecs).hasSize(3);

Expected size: 3 but was: 2 in:
  [Prestec{isbn='978-0000000001', empleat='Marta Ruiz', venc=2026-03-15},
   Prestec{isbn='978-0000000002', empleat='Marta Ruiz', venc=2026-03-16}]

import static org.assertj.core.api.Assertions.*;

// Encadenament sobre col.leccions
assertThat(prestecsVencuts)
        .hasSize(2)
        .extracting(Prestec::getEmpleat)
        .extracting(Empleat::getNom)
        .containsExactlyInAnyOrder("Marta Ruiz", "Diego Alonso");

// BigDecimal: compara VALOR, no escala. 2.50 vs 2.5 no falla.
assertThat(multa).isEqualByComparingTo("2.50");

// Optional (10-04)
assertThat(repositori.cercarPerIsbn("978-0000000001"))
        .isPresent()
        .get()
        .extracting(Material::getTitol)
        .isEqualTo("Java Eficac");

// Excepcions, amb mes detall
assertThatThrownBy(() -> gestor.prestar("978-9999999999", "[email protected]"))
        .isInstanceOf(MaterialNoTrobatException.class)
        .hasMessageContaining("978-9999999999")
        .hasNoCause();

// Comparar objectes camp a camp, ignorant l'id generat
assertThat(prestecDesat)
        .usingRecursiveComparison()
        .ignoringFields("id", "version")
        .isEqualTo(prestecEsperat);

// Predicats sobre tots els elements
assertThat(prestecsActius)
        .isNotEmpty()
        .allMatch(p -> p.getDataDevolucio().isEmpty())
        .allSatisfy(p -> assertThat(p.getDataVenciment()).isAfter(p.getDataPrestec()));

class GestorPrestecsTest {

    private Clock rellotgeFix;
    private CalculadoraMultes calculadora;
    private GestorPrestecs gestor;
    private Empleat marta;

    @BeforeAll
    static void prepararTotaLaClasse() {
        // UNA vegada, abans de totes les proves. static (llevat d'amb @TestInstance PER_CLASS)
        // Per a recursos cars i COMPARTITS: arrencar un contenidor, carregar un fitxer gran.
    }

    @BeforeEach
    void prepararCadaProva() {
        // ABANS DE CADA prova: estat net, sense contaminacio entre proves
        rellotgeFix = Clock.fixed(Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));
        calculadora = new CalculadoraMultes(propietatsDeProva(), rellotgeFix);
        gestor = new GestorPrestecs(new RepositoriEnMemoria(), calculadora,
                                    new AvisosEnMemoria(), propietatsDeProva(), rellotgeFix);
        marta = new Empleat("[email protected]", "Marta Ruiz");
    }

    @AfterEach
    void netejarCadaProva() {
        // Despres de cada prova. Amb recursos gestionats, rarament necessari.
    }

    @AfterAll
    static void netejarTotaLaClasse() {
        // Una vegada, al final. Tancar el que s'ha obert a @BeforeAll.
    }
}

private Prestec prestecAmbRetardDe(int dies) {
    LocalDate avui = LocalDate.now(rellotgeFix);
    return new Prestec(unLlibre(), marta, avui.minusDays(15 + dies), avui.minusDays(dies));
}

private Material unLlibre() {
    return new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch");
}

class ComptadorTest {

    private int comptador = 0;   // es reinicia a CADA prova

    @Test void primera()  { comptador++; assertEquals(1, comptador); }   // passa
    @Test void segona()   { comptador++; assertEquals(1, comptador); }   // TAMBE passa
}

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class CatalegTest {

    private List<Material> cataleg;   // compartit per TOTES les proves

    @BeforeAll
    void carregarCataleg() {          // ja no cal que sigui static
        cataleg = carregarCatalegGran();
    }
}

@Test
@Disabled("Pendent de decidir la politica de multes per a revistes (BIB-142)")
void multaDeRevistaEsLaMeitat() { ... }

@Test
@EnabledOnOs(OS.LINUX)
void caminsDePermisosPosix() { ... }

@Test
@DisabledOnOs(OS.WINDOWS)
void enllacosSimbolics() { ... }

@Test
@EnabledOnJre(JRE.JAVA_21)
void filsVirtuals() { ... }                         // repren 10-06

@Test
@EnabledIfSystemProperty(named = "proves.integracio", matches = "true")
void contraLaBaseDeDadesReal() { ... }

@Test
@EnabledIfEnvironmentVariable(named = "CI", matches = "true")
void nomesEnIntegracioContinua() { ... }

@Test void multaDUnDia()     { assertThat(calcular(1)).isEqualByComparingTo("0.50"); }
@Test void multaDeDosDies()  { assertThat(calcular(2)).isEqualByComparingTo("1.00"); }
@Test void multaDeCincDies() { assertThat(calcular(5)).isEqualByComparingTo("2.50"); }
@Test void multaDeDeuDies()  { assertThat(calcular(10)).isEqualByComparingTo("5.00"); }
// ... vuit mes

@ParameterizedTest(name = "{0} dies de retard -> {1} EUR")
@CsvSource({
        "  1,  0.50",
        "  2,  1.00",
        "  5,  2.50",
        " 10,  5.00",
        " 39, 19.50",
        " 40, 20.00",   // just el maxim
        " 41, 20.00",   // passat el maxim: es limita
        "200, 20.00",   // molt passat: continua limitat
        "  0,  0.00",   // venc avui: sense retard
        " -1,  0.00",   // venc dema
        " -5,  0.00",
        "-30,  0.00"
})
void laMultaEsCalculaSegonsElsDiesDeRetard(int diesRetard, BigDecimal multaEsperada) {
    Prestec prestec = prestecAmbRetardDe(diesRetard);
    assertThat(calculadora.calcular(prestec)).isEqualByComparingTo(multaEsperada);
}

laMultaEsCalculaSegonsElsDiesDeRetard
  ✔ 1 dies de retard -> 0.50 EUR
  ✔ 5 dies de retard -> 2.50 EUR
  ✔ 40 dies de retard -> 20.00 EUR
  ✔ 41 dies de retard -> 20.00 EUR
  ...

// Tots els estats de l'enum (04-07)
@ParameterizedTest
@EnumSource(EstatPrestec.class)
void totEstatTeDescripcioNoBuida(EstatPrestec estat) {
    assertThat(estat.getDescripcio()).isNotBlank();
}

// Nomes alguns
@ParameterizedTest
@EnumSource(value = EstatPrestec.class, names = {"ACTIU", "VENCUT"})
void elsEstatsNoFinalitzatsPermetenDevolucio(EstatPrestec estat) {
    assertThat(estat.permetDevolucio()).isTrue();
}

// Validacio d'entrades invalides: null, buit i brossa
@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = { " ", "abc", "978", "978-000000000X", "1234567890123" })
void unIsbnInvalidEsRebutjat(String isbnInvalid) {
    assertThatThrownBy(() -> new Isbn(isbnInvalid))
            .isInstanceOf(IsbnInvalidException.class);
}

class GestorPrestecsTest {

    // El metode ha de ser static (o la classe, @TestInstance(PER_CLASS))
    static Stream<Arguments> escenarisDePrestec() {
        return Stream.of(
            Arguments.of("Empleat sense prestecs, material disponible",
                         0, 3, true,  null),
            Arguments.of("Empleat al limit",
                         3, 3, false, LimitPrestecsException.class),
            Arguments.of("Material sense exemplars",
                         1, 0, false, SenseExemplarsException.class),
            Arguments.of("Empleat a un prestec del limit",
                         2, 5, true,  null)
        );
    }

    @ParameterizedTest(name = "{0}")
    @MethodSource("escenarisDePrestec")
    void escenarisDePrestecDeBiblioTech(String descripcio,
                                        int prestecsActius,
                                        int exemplarsDisponibles,
                                        boolean hauriaDeTenirExit,
                                        Class<? extends Exception> excepcioEsperada) {

        // PREPARAR
        Material material = new Llibre("978-0000000001", "Java Eficac",
                                       exemplarsDisponibles, "J. Bloch");
        Empleat marta = new Empleat("[email protected]", "Marta Ruiz");
        repositori.desar(material);
        repositori.desar(marta);
        for (int i = 0; i < prestecsActius; i++) {
            repositori.desarPrestec(new Prestec(unAltreLlibre(i), marta, avui(), 15));
        }

        // ACTUAR i COMPROVAR
        if (hauriaDeTenirExit) {
            assertThat(gestor.prestar("978-0000000001", marta.getCorreu())).isNotNull();
        } else {
            assertThatThrownBy(() -> gestor.prestar("978-0000000001", marta.getCorreu()))
                    .isInstanceOf(excepcioEsperada);
        }
    }
}

static Stream<Material> materialsDeProva() {
    return Stream.of(
        new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch"),
        new Revista("978-0000000010", "Java Magazine", 5, 42),
        new Dvd("978-0000000020", "Curs de Java", 1, 180));
}

@ParameterizedTest
@MethodSource("materialsDeProva")
void totMaterialEsPotPrestarSiHiHaExemplars(Material material) {
    int abans = material.getExemplarsDisponibles();
    material.prestarUnExemplar();
    assertThat(material.getExemplarsDisponibles()).isEqualTo(abans - 1);
}

@DisplayName("GestorPrestecs")
class GestorPrestecsTest {

    private GestorPrestecs gestor;
    private Empleat marta;

    @BeforeEach
    void prepararComu() {
        gestor = crearGestor();
        marta = new Empleat("[email protected]", "Marta Ruiz");
    }

    @Nested
    @DisplayName("quan l'empleat no té préstecs actius")
    class SensePrestecsActius {

        @Test
        @DisplayName("pot prestar un material disponible")
        void potPrestar() {
            Prestec prestec = gestor.prestar("978-0000000001", marta.getCorreu());
            assertThat(prestec).isNotNull();
        }

        @Test
        @DisplayName("la data de venciment són 15 dies després")
        void vencimentCorrecte() {
            Prestec prestec = gestor.prestar("978-0000000001", marta.getCorreu());
            assertThat(prestec.getDataVenciment())
                    .isEqualTo(LocalDate.now(rellotgeFix).plusDays(15));
        }
    }

    @Nested
    @DisplayName("quan l'empleat està al límit de préstecs")
    class AlLimit {

        @BeforeEach
        void prestarFinsAlLimit() {            // preparacio PROPIA d'aquest escenari
            gestor.prestar("978-0000000001", marta.getCorreu());
            gestor.prestar("978-0000000002", marta.getCorreu());
            gestor.prestar("978-0000000003", marta.getCorreu());
        }

        @Test
        @DisplayName("no pot prestar més")
        void noPotPrestarMes() {
            assertThatThrownBy(() -> gestor.prestar("978-0000000004", marta.getCorreu()))
                    .isInstanceOf(LimitPrestecsException.class);
        }

        @Test
        @DisplayName("pot prestar de nou després de retornar-ne un")
        void potDespresDeRetornar() {
            gestor.retornar("978-0000000001", marta.getCorreu());
            assertThat(gestor.prestar("978-0000000004", marta.getCorreu())).isNotNull();
        }
    }
}

GestorPrestecs
  quan l'empleat no té préstecs actius
    ✔ pot prestar un material disponible
    ✔ la data de venciment són 15 dies després
  quan l'empleat està al límit de préstecs
    ✔ no pot prestar més
    ✔ pot prestar de nou després de retornar-ne un

@Tag("rapida")
class CalculadoraMultesTest { ... }

@Tag("lenta")
@Tag("integracio")
class PrestecRepositoryIT { ... }

mvn test -Dgroups="rapida"                        # nomes les rapides
mvn test -DexcludedGroups="lenta,integracio"      # tot menys el lent

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <excludedGroups>integracio</excludedGroups>
    </configuration>
</plugin>

class EscripturaAtomicaTest {

    @TempDir
    Path directoriTemporal;   // JUnit el crea abans i l'ESBORRA despres, sol

    @Test
    void escriuElFitxerCompletONoL_Escriu() throws IOException {

        Path desti = directoriTemporal.resolve("cataleg.csv");
        EscripturaAtomica escriptura = new EscripturaAtomica();

        escriptura.escriure(desti, List.of(
                "isbn;titol;exemplars",
                "978-0000000001;Java Eficac;3"));

        assertThat(desti).exists();
        assertThat(Files.readAllLines(desti, StandardCharsets.UTF_8))
                .containsExactly(
                        "isbn;titol;exemplars",
                        "978-0000000001;Java Eficac;3");
    }

    @Test
    void noDeixaFitxersTemporalsDespresDUnaEscripturaCorrecta() throws IOException {
        Path desti = directoriTemporal.resolve("cataleg.csv");
        new EscripturaAtomica().escriure(desti, List.of("linia"));

        try (Stream<Path> fitxers = Files.list(directoriTemporal)) {
            assertThat(fitxers).containsExactly(desti);   // ni .tmp ni .bak
        }
    }

    @Test
    void elFitxerOriginalSobreviuSiLEscripturaFalla() throws IOException {
        Path desti = directoriTemporal.resolve("cataleg.csv");
        Files.writeString(desti, "contingut original", StandardCharsets.UTF_8);

        assertThatThrownBy(() -> new EscripturaAtomica().escriure(desti, liniesQueFallen()))
                .isInstanceOf(PersistenciaException.class);

        // La garantia de l'escriptura atomica: l'original intacte
        assertThat(Files.readString(desti, StandardCharsets.UTF_8))
                .isEqualTo("contingut original");
    }
}

// NO PROVABLE: crea les seves dependencies
public class GestorPrestecs {
    private final Repositori repo = new RepositoriJpa();     // necessita base de dades
    private final ServeiAvisos avisos = new AvisosSmtp();    // necessita servidor SMTP
}

// PROVABLE: les rep
public class GestorPrestecs {
    public GestorPrestecs(Repositori repo, ServeiAvisos avisos) { ... }
}

// Pura: es prova amb una linia
public static BigDecimal calcularMulta(long diesRetard, BigDecimal perDia, BigDecimal maxima) {
    if (diesRetard <= 0) return BigDecimal.ZERO;
    return perDia.multiply(BigDecimal.valueOf(diesRetard)).min(maxima);
}

// MALAMENT: busca el seu estat en un lloc global
public BigDecimal calcular(Prestec p) {
    BigDecimal perDia = ReglesNegoci.multaPerDia();    // static: no es pot substituir
    LocalDate avui = LocalDate.now();                  // rellotge del sistema
    ...
}

// BE: el rep
public BigDecimal calcular(Prestec p) {
    BigDecimal perDia = propietats.multa().eurosPerDia();   // injectat
    LocalDate avui = LocalDate.now(rellotge);               // injectat
    ...
}

public BigDecimal calcular(Prestec prestec) {
    LocalDate avui = LocalDate.now();   // el rellotge del SISTEMA
    ...
}

public BigDecimal calcular(Prestec prestec) {
    LocalDate avui = LocalDate.now(rellotge);   // el rellotge INJECTAT
    ...
}

class CalculadoraMultesTest {

    // "Avui" es SEMPRE el 20 de marc de 2026. En qualsevol maquina, qualsevol dia.
    private static final Clock RELLOTGE_FIX = Clock.fixed(
            Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));

    private CalculadoraMultes calculadora;

    @BeforeEach
    void preparar() {
        calculadora = new CalculadoraMultes(propietatsDeProva(), RELLOTGE_FIX);
    }

    @Test
    void unPrestecVencutFaCincDiesGeneraDosEurosCinquanta() {
        Prestec prestec = prestecQueVaVencerEl(LocalDate.of(2026, 3, 15));
        assertThat(calculadora.calcular(prestec)).isEqualByComparingTo("2.50");
    }

    @Test
    void unPrestecQueVencAvuiNoGeneraMulta() {
        Prestec prestec = prestecQueVaVencerEl(LocalDate.of(2026, 3, 20));
        assertThat(calculadora.calcular(prestec)).isEqualByComparingTo("0.00");
    }

    @Test
    void unPrestecQueVencDemaNoGeneraMulta() {
        Prestec prestec = prestecQueVaVencerEl(LocalDate.of(2026, 3, 21));
        assertThat(calculadora.calcular(prestec)).isEqualByComparingTo("0.00");
    }
}

@Test
void laMultaCreixUnEuroMigPerCadaDiaQuePassa() {

    LocalDate venciment = LocalDate.of(2026, 3, 15);
    Prestec prestec = prestecQueVaVencerEl(venciment);

    // Dia 16: 1 dia de retard
    var dia16 = new CalculadoraMultes(propietats, rellotgeEn(LocalDate.of(2026, 3, 16)));
    assertThat(dia16.calcular(prestec)).isEqualByComparingTo("0.50");

    // Dia 20: 5 dies
    var dia20 = new CalculadoraMultes(propietats, rellotgeEn(LocalDate.of(2026, 3, 20)));
    assertThat(dia20.calcular(prestec)).isEqualByComparingTo("2.50");

    // Dia 100: limitat al maxim
    var dia100 = new CalculadoraMultes(propietats, rellotgeEn(LocalDate.of(2026, 6, 23)));
    assertThat(dia100.calcular(prestec)).isEqualByComparingTo("20.00");
}

private static Clock rellotgeEn(LocalDate data) {
    return Clock.fixed(data.atStartOfDay(ZoneId.of("Europe/Madrid")).toInstant(),
                       ZoneId.of("Europe/Madrid"));
}

// NO ES POT PROVAR
public class CalculadoraMultes {
    public static BigDecimal calcular(Prestec p) {
        BigDecimal perDia = ReglesNegoci.multaPerDia();    // static: no se substitueix
        LocalDate avui = LocalDate.now();                  // rellotge del sistema
        ...
    }
}

// NO ES POT PROVAR SENSE XARXA
public class EnriquidorCataleg {
    public Material enriquir(Material material) {
        ClientMetadades client = new ClientMetadades();   // crida una API real
        return client.enriquir(material);
    }
}

public void processar(Prestec p) {
    calcular(p);
    enviarCorreu(p);                    // envia un correu DE VERITAT
    System.out.println("Processat");    // no es pot comprovar
    fitxerLog.append(...);              // escriu en disc
}

// FRAGIL: comprova COM es fa
verify(repositori).findById(1L);
verify(repositori).save(any());
verify(calculadora).calcular(any());
// Si dema es fa servir findByIsbn, la prova falla encara que el resultat sigui identic.

// ROBUSTA: comprova QUIN resultat s'obte
assertThat(gestor.prestar("978-0000000001", "[email protected]"))
        .extracting(Prestec::getDataVenciment)
        .isEqualTo(LocalDate.of(2026, 3, 16));

// MALAMENT
servei.processarAsincron();
Thread.sleep(1000);              // i si triga 1100 ms a la integracio continua?
assertThat(resultat).isNotNull();

@Test
void provaDePrestec() {
    Prestec p = gestor.prestar("978-0000000001", "[email protected]");
    assertNotNull(p);       // i que? No comprova cap regla
}

// Inutil: si la formula esta malament, la prova esta malament igual
BigDecimal esperat = perDia.multiply(BigDecimal.valueOf(dies)).min(maxima);
assertThat(calculadora.calcular(prestec)).isEqualByComparingTo(esperat);

@Test
void elCatalegConcurrentSuportaCentFilsSimultanis() throws Exception {

    CatalegConcurrent cataleg = new CatalegConcurrent();
    int fils = 100, operacions = 1000;

    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {   // 10-06
        CountDownLatch llestos = new CountDownLatch(fils);
        CountDownLatch sortida = new CountDownLatch(1);

        for (int i = 0; i < fils; i++) {
            executor.submit(() -> {
                llestos.countDown();
                sortida.await();                   // tots comencen ALHORA
                for (int j = 0; j < operacions; j++) cataleg.incrementarConsultes();
                return null;
            });
        }
        llestos.await(5, TimeUnit.SECONDS);
        sortida.countDown();                       // tret simultani
    }   // el tancament de l'executor espera que acabin

    assertThat(cataleg.getConsultes()).isEqualTo((long) fils * operacions);
}

mvn test                                     # compila i executa les proves unitaries
mvn test -Dtest=CalculadoraMultesTest        # nomes una classe
mvn test -Dtest=CalculadoraMultesTest#multa* # nomes metodes que comencin per "multa"
mvn test -Dgroups="rapida"                   # nomes les etiquetades
mvn verify                                   # unitaries + integracio (failsafe)
mvn package -DskipTests                      # empaqueta SENSE executar proves

[ERROR] Failures:
[ERROR]   CalculadoraMultesTest.laMultaEsLimitaAlMaxim:47
           expected: 20.00 but was: 100.00
[INFO] Tests run: 24, Failures: 1, Errors: 0, Skipped: 0
[INFO] BUILD FAILURE

@Test
void cobertura100() {
    calculadora.calcular(prestec);   // s'executa... i no es comprova res
}

@SpringBootTest
class BiblioTechApplicationTests {

    @Autowired
    private GestorPrestecs gestor;

    @Test
    void elContextEsCarregaCorrectament() {
        assertThat(gestor).isNotNull();
    }
}

@DataJpaTest
class PrestecRepositoryTest {

    @Autowired private PrestecRepository repositori;
    @Autowired private TestEntityManager em;

    @Test
    void trobaElsPrestecsVencutsSenseRetornar() {
        Material llibre = em.persist(new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch"));
        Empleat marta = em.persist(new Empleat("[email protected]", "Marta Ruiz"));
        em.persist(new Prestec(llibre, marta,
                LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 10)));
        em.flush();

        List<Prestec> vencuts = repositori.vencuts(LocalDate.of(2026, 3, 20));

        assertThat(vencuts).hasSize(1)
                .first().extracting(p -> p.getMaterial().getTitol())
                .isEqualTo("Java Eficac");
    }
}

src/test/java/com/nexussoftware/bibliotech/
├── domini/
│   ├── PrestecTest.java               <- regles de venciment i devolucio
│   ├── MaterialTest.java              <- exemplars disponibles
│   └── IsbnTest.java                  <- validacio
├── servei/
│   ├── CalculadoraMultesTest.java     <- multes, amb Clock fix
│   └── GestorPrestecsTest.java        <- limit de prestecs
├── persistencia/
│   └── EscripturaAtomicaTest.java     <- @TempDir
└── BiblioTechApplicationTests.java    <- @SpringBootTest: carrega del context

package com.nexussoftware.bibliotech.servei;

import static org.assertj.core.api.Assertions.*;

import java.math.BigDecimal;
import java.time.*;
import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

@DisplayName("Càlcul de multes de BiblioTech")
class CalculadoraMultesTest {

    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");
    private static final LocalDate AVUI = LocalDate.of(2026, 3, 20);
    private static final Clock RELLOTGE_FIX =
            Clock.fixed(AVUI.atStartOfDay(MADRID).toInstant(), MADRID);

    private CalculadoraMultes calculadora;
    private Empleat marta;
    private Material llibre;

    @BeforeEach
    void preparar() {
        var propietats = new PropietatsBiblioTech(
                "BiblioTech - Nexus Software",
                new PropietatsBiblioTech.Prestec(15, 3),
                new PropietatsBiblioTech.Multa(new BigDecimal("0.50"), new BigDecimal("20.00")),
                new PropietatsBiblioTech.Reserva(3));

        calculadora = new CalculadoraMultes(propietats, RELLOTGE_FIX);
        marta = new Empleat("[email protected]", "Marta Ruiz");
        llibre = new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch");
    }

    @Nested
    @DisplayName("quan el préstec continua en termini")
    class EnTermini {

        @Test
        @DisplayName("no hi ha multa si venç dins d'una setmana")
        void senseMultaSiVencEnUnaSetmana() {
            assertThat(calculadora.calcular(prestecQueVenc(AVUI.plusDays(7))))
                    .isEqualByComparingTo("0.00");
        }

        @Test
        @DisplayName("no hi ha multa el mateix dia del venciment")
        void senseMultaElDiaDelVenciment() {
            assertThat(calculadora.calcular(prestecQueVenc(AVUI)))
                    .isEqualByComparingTo("0.00");
        }
    }

    @Nested
    @DisplayName("quan el préstec està vençut")
    class Vencut {

        @ParameterizedTest(name = "{0} dies de retard -> {1} EUR")
        @CsvSource({
                "  1,  0.50", "  2,  1.00", "  5,  2.50", " 10,  5.00",
                " 39, 19.50", " 40, 20.00", " 41, 20.00", "200, 20.00"
        })
        @DisplayName("la multa és 0,50 € per dia fins al màxim de 20 €")
        void multaPerDiesDeRetard(int dies, BigDecimal esperada) {
            assertThat(calculadora.calcular(prestecQueVenc(AVUI.minusDays(dies))))
                    .isEqualByComparingTo(esperada);
        }

        @Test
        @DisplayName("la multa mai no supera el màxim configurat")
        void maiSuperaElMaxim() {
            assertThat(calculadora.calcular(prestecQueVenc(AVUI.minusYears(2))))
                    .isEqualByComparingTo("20.00");
        }
    }

    @Nested
    @DisplayName("quan el préstec ja s'ha retornat")
    class Retornat {

        @Test
        @DisplayName("no hi ha multa encara que es retornés tard")
        void senseMultaDespresDeLaDevolucio() {
            Prestec prestec = prestecQueVenc(AVUI.minusDays(30));
            prestec.retornar(AVUI.minusDays(10));

            assertThat(calculadora.calcular(prestec)).isEqualByComparingTo("0.00");
        }
    }

    // --- fabriques d'escenaris ---
    private Prestec prestecQueVenc(LocalDate venciment) {
        return new Prestec(llibre, marta, venciment.minusDays(15), venciment);
    }
}

mvn test

[INFO] Running com.nexussoftware.bibliotech.servei.CalculadoraMultesTest
[INFO] Tests run: 12, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.089 s
[INFO] Running com.nexussoftware.bibliotech.domini.PrestecTest
[INFO] Tests run: 8, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.021 s
...
[INFO] Tests run: 41, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS
[INFO] Total time: 6.412 s

@Entity
public class Prestec {

    @Id @GeneratedValue private Long id;
    @ManyToOne(fetch = FetchType.LAZY) private Material material;
    @ManyToOne(fetch = FetchType.LAZY) private Empleat empleat;
    private LocalDate dataPrestec;
    private LocalDate dataVenciment;
    private LocalDate dataDevolucio;
    @Enumerated(EnumType.STRING) private EstatPrestec estat;

    public Prestec(Material material, Empleat empleat, LocalDate dataPrestec, int dies) {
        this.material = material;
        this.empleat = empleat;
        this.dataPrestec = dataPrestec;
        this.dataVenciment = dataPrestec.plusDays(dies);
        this.estat = EstatPrestec.ACTIU;
    }

    public boolean estaVencut(LocalDate avui) {
        return dataDevolucio == null && avui.isAfter(dataVenciment);
    }

    public void retornar(LocalDate data) {
        if (dataDevolucio != null) {
            throw new PrestecJaRetornatException(id);
        }
        if (data.isBefore(dataPrestec)) {
            throw new DataInvalidaException("No es pot retornar abans de prestar");
        }
        this.dataDevolucio = data;
        this.estat = EstatPrestec.RETORNAT;
    }

    public Optional<LocalDate> getDataDevolucio() {
        return Optional.ofNullable(dataDevolucio);
    }
}

public class ServeiAvisosVenciment {

    public int enviarAvisosDelDia() {
        int enviats = 0;
        LocalDate avui = LocalDate.now();

        RepositoriPrestecs repositori = new RepositoriPrestecsJpa();
        List<Prestec> prestecs = repositori.cercarTots();

        for (Prestec p : prestecs) {
            long dies = ChronoUnit.DAYS.between(avui, p.getDataVenciment());
            if (dies == Integer.parseInt(ReglesNegoci.get("avis.dies.antelacio", "2"))) {
                ClientCorreu correu = new ClientCorreu("smtp.nexussoftware.com", 587);
                correu.enviar(p.getEmpleat().getCorreu(),
                              "El teu prestec de " + p.getMaterial().getTitol() + " venc aviat");
                System.out.println("Avis enviat a " + p.getEmpleat().getCorreu());
                enviats++;
            }
        }
        return enviats;
    }
}

public class GestorRenovacions {

    private static final int MAX_RENOVACIONS = 2;
    private final Clock rellotge;

    public GestorRenovacions(Clock rellotge) { this.rellotge = rellotge; }

    public LocalDate renovar(Prestec prestec, int dies) {
        if (prestec.getRenovacions() >= MAX_RENOVACIONS) {
            throw new LimitRenovacionsException(prestec.getId());
        }
        if (prestec.getDataDevolucio().isPresent()) {
            throw new PrestecJaRetornatException(prestec.getId());
        }

        LocalDate avui = LocalDate.now(rellotge);
        LocalDate novaData = prestec.getDataVenciment().plusDays(dies);

        if (novaData.isBefore(avui)) {
            novaData = avui;
        }

        prestec.actualitzarVenciment(novaData);
        prestec.incrementarRenovacions();
        return novaData;
    }
}

package com.nexussoftware.bibliotech.domini;

import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.assertAll;

import java.time.LocalDate;
import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

@DisplayName("Préstec")
class PrestecTest {

    private static final LocalDate DATA_PRESTEC = LocalDate.of(2026, 3, 1);
    private static final int DIES = 15;
    private static final LocalDate VENCIMENT = LocalDate.of(2026, 3, 16);

    private Material llibre;
    private Empleat marta;
    private Prestec prestec;

    @BeforeEach
    void preparar() {
        llibre = new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch");
        marta = new Empleat("[email protected]", "Marta Ruiz");
        prestec = new Prestec(llibre, marta, DATA_PRESTEC, DIES);
    }

    @Nested
    @DisplayName("acabat de crear")
    class AcabatDeCrear {

        @Test
        @DisplayName("(1) té totes les dades correctes")
        void dadesCorrectes() {
            assertAll("dades del prestec",
                    () -> assertThat(prestec.getMaterial()).isEqualTo(llibre),
                    () -> assertThat(prestec.getEmpleat()).isEqualTo(marta),
                    () -> assertThat(prestec.getDataPrestec()).isEqualTo(DATA_PRESTEC),
                    () -> assertThat(prestec.getDataVenciment()).isEqualTo(VENCIMENT),
                    () -> assertThat(prestec.getEstat()).isEqualTo(EstatPrestec.ACTIU),
                    () -> assertThat(prestec.getDataDevolucio()).isEmpty());
        }
    }

    @Nested
    @DisplayName("comprovació de venciment")
    class Venciment {

        // (2) cinc casos, inclosos els limits
        @ParameterizedTest(name = "el {0} -> vencut = {1}")
        @CsvSource({
                "2026-03-01, false",   // el dia del prestec
                "2026-03-15, false",   // vigilia del venciment
                "2026-03-16, false",   // LIMIT: el mateix dia NO esta vencut
                "2026-03-17, true",    // LIMIT: el dia seguent SI
                "2026-04-30, true",    // molt despres
                "2027-01-01, true"
        })
        void estaVencutSegonsLaData(LocalDate avui, boolean esperat) {
            assertThat(prestec.estaVencut(avui)).isEqualTo(esperat);
        }
    }

    @Nested
    @DisplayName("en retornar")
    class Devolucio {

        @Test
        @DisplayName("(3) registra la data i canvia l'estat")
        void devolucioCorrecta() {
            LocalDate dataDevolucio = LocalDate.of(2026, 3, 10);

            prestec.retornar(dataDevolucio);

            assertAll(
                    () -> assertThat(prestec.getDataDevolucio()).contains(dataDevolucio),
                    () -> assertThat(prestec.getEstat()).isEqualTo(EstatPrestec.RETORNAT));
        }

        @Test
        @DisplayName("(4) retornar dues vegades llança PrestecJaRetornatException")
        void noEsPotRetornarDuesVegades() {
            prestec.retornar(LocalDate.of(2026, 3, 10));

            assertThatThrownBy(() -> prestec.retornar(LocalDate.of(2026, 3, 11)))
                    .isInstanceOf(PrestecJaRetornatException.class);
        }

        @Test
        @DisplayName("(5) retornar abans de prestar llança DataInvalidaException")
        void noEsPotRetornarAbansDePrestar() {
            assertThatThrownBy(() -> prestec.retornar(DATA_PRESTEC.minusDays(1)))
                    .isInstanceOf(DataInvalidaException.class)
                    .hasMessageContaining("abans de prestar");
        }

        @Test
        @DisplayName("(6) un préstec retornat mai no està vençut, encara que es retornés tard")
        void retornatMaiEstaVencut() {
            prestec.retornar(LocalDate.of(2026, 4, 30));   // 45 dies tard

            assertThat(prestec.estaVencut(LocalDate.of(2027, 1, 1))).isFalse();
        }
    }
}

package com.nexussoftware.bibliotech.servei;

import java.time.Clock;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.List;
import org.slf4j.*;
import org.springframework.stereotype.Service;

@Service
public class ServeiAvisosVenciment {

    private static final Logger log = LoggerFactory.getLogger(ServeiAvisosVenciment.class);

    private final RepositoriPrestecs repositori;      // interficie
    private final ServeiAvisos avisos;                // interficie
    private final PropietatsBiblioTech propietats;    // configuracio injectada
    private final Clock rellotge;                     // temps controlable

    public ServeiAvisosVenciment(RepositoriPrestecs repositori,
                                 ServeiAvisos avisos,
                                 PropietatsBiblioTech propietats,
                                 Clock rellotge) {
        this.repositori = repositori;
        this.avisos = avisos;
        this.propietats = propietats;
        this.rellotge = rellotge;
    }

    public int enviarAvisosDelDia() {
        LocalDate avui = LocalDate.now(rellotge);
        int diesAntelacio = propietats.avis().diesAntelacio();

        List<Prestec> aAvisar = repositori.cercarActius().stream()
                .filter(p -> ChronoUnit.DAYS.between(avui, p.getDataVenciment()) == diesAntelacio)
                .toList();

        aAvisar.forEach(p -> {
            avisos.avisar(p.getEmpleat(),
                    "El teu prestec de " + p.getMaterial().getTitol() + " venc aviat");
            log.info("Avis enviat a {}", p.getEmpleat().getCorreu());
        });

        return aAvisar.size();
    }
}

package com.nexussoftware.bibliotech.servei;

import static org.assertj.core.api.Assertions.assertThat;

import java.time.*;
import java.util.*;
import org.junit.jupiter.api.*;

@DisplayName("Avisos de venciment")
class ServeiAvisosVencimentTest {

    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");
    private static final LocalDate AVUI = LocalDate.of(2026, 3, 20);
    private static final Clock RELLOTGE = Clock.fixed(AVUI.atStartOfDay(MADRID).toInstant(), MADRID);

    // Doble de prova tipus FAKE: implementacio real, pero en memoria
    static class RepositoriEnMemoria implements RepositoriPrestecs {
        private final List<Prestec> prestecs = new ArrayList<>();
        void afegir(Prestec p) { prestecs.add(p); }
        @Override public List<Prestec> cercarActius() { return List.copyOf(prestecs); }
    }

    // Doble tipus SPY casola: registra el que se li demana
    static class AvisosRegistrats implements ServeiAvisos {
        final List<String> destinataris = new ArrayList<>();
        final List<String> missatges = new ArrayList<>();
        @Override public void avisar(Empleat destinatari, String missatge) {
            destinataris.add(destinatari.getCorreu());
            missatges.add(missatge);
        }
    }

    private RepositoriEnMemoria repositori;
    private AvisosRegistrats avisos;
    private ServeiAvisosVenciment servei;

    @BeforeEach
    void preparar() {
        repositori = new RepositoriEnMemoria();
        avisos = new AvisosRegistrats();

        var propietats = propietatsAmbAntelacioDe(2);   // avisar 2 dies abans
        servei = new ServeiAvisosVenciment(repositori, avisos, propietats, RELLOTGE);
    }

    @Test
    @DisplayName("avisa quan falten exactament els dies configurats")
    void avisaAmbLAntelacioConfigurada() {
        repositori.afegir(prestecQueVenc(AVUI.plusDays(2), "[email protected]"));

        int enviats = servei.enviarAvisosDelDia();

        assertThat(enviats).isEqualTo(1);
        assertThat(avisos.destinataris).containsExactly("[email protected]");
        assertThat(avisos.missatges).first().asString().contains("Java Eficac");
    }

    @Test
    @DisplayName("no avisa si falten més o menys dies dels configurats")
    void noAvisaForaDeLaFinestra() {
        repositori.afegir(prestecQueVenc(AVUI.plusDays(1), "[email protected]"));  // 1 dia
        repositori.afegir(prestecQueVenc(AVUI.plusDays(3), "[email protected]"));  // 3 dies
        repositori.afegir(prestecQueVenc(AVUI,             "[email protected]"));  // avui
        repositori.afegir(prestecQueVenc(AVUI.minusDays(5),"[email protected]"));  // vencut

        int enviats = servei.enviarAvisosDelDia();

        assertThat(enviats).isZero();
        assertThat(avisos.destinataris).isEmpty();
    }

    @Test
    @DisplayName("compta correctament els avisos enviats")
    void comptaElsAvisos() {
        repositori.afegir(prestecQueVenc(AVUI.plusDays(2), "[email protected]"));
        repositori.afegir(prestecQueVenc(AVUI.plusDays(2), "[email protected]"));
        repositori.afegir(prestecQueVenc(AVUI.plusDays(2), "[email protected]"));
        repositori.afegir(prestecQueVenc(AVUI.plusDays(9), "[email protected]"));

        assertThat(servei.enviarAvisosDelDia()).isEqualTo(3);
        assertThat(avisos.destinataris).containsExactlyInAnyOrder(
                "[email protected]",
                "[email protected]",
                "[email protected]");
    }

    private Prestec prestecQueVenc(LocalDate venciment, String correu) {
        return new Prestec(
                new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch"),
                new Empleat(correu, "Empleat de prova"),
                venciment.minusDays(15), venciment);
    }
}

package com.nexussoftware.bibliotech.servei;

import static org.assertj.core.api.Assertions.*;

import java.time.*;
import org.junit.jupiter.api.*;

@DisplayName("Renovació de préstecs")
class GestorRenovacionsTest {

    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");
    private static final LocalDate AVUI = LocalDate.of(2026, 3, 20);
    private static final Clock RELLOTGE = Clock.fixed(AVUI.atStartOfDay(MADRID).toInstant(), MADRID);

    private GestorRenovacions gestor;

    @BeforeEach
    void preparar() { gestor = new GestorRenovacions(RELLOTGE); }

    @Test
    @DisplayName("renovar afegeix els dies a la data de venciment")
    void renovarAfegeixDies() {
        Prestec prestec = prestecQueVenc(AVUI.plusDays(3));   // venc el 23

        LocalDate nova = gestor.renovar(prestec, 15);

        assertThat(nova).isEqualTo(LocalDate.of(2026, 4, 7));   // 23 + 15
        assertThat(prestec.getRenovacions()).isEqualTo(1);
    }

    @Test
    @DisplayName("no es pot renovar més de dues vegades")
    void limitDeRenovacions() {
        Prestec prestec = prestecQueVenc(AVUI.plusDays(3));
        gestor.renovar(prestec, 15);
        gestor.renovar(prestec, 15);

        assertThatThrownBy(() -> gestor.renovar(prestec, 15))
                .isInstanceOf(LimitRenovacionsException.class);
    }

    @Test
    @DisplayName("no es pot renovar un préstec ja retornat")
    void noEsRenovaUnRetornat() {
        Prestec prestec = prestecQueVenc(AVUI.plusDays(3));
        prestec.retornar(AVUI.minusDays(1));

        assertThatThrownBy(() -> gestor.renovar(prestec, 15))
                .isInstanceOf(PrestecJaRetornatException.class);
    }

    // ===== LA PROVA QUE REVELA EL BUG =====
    @Test
    @DisplayName("renovar un préstec molt vençut ha d'afegir els dies des d'AVUI, no des del passat")
    void renovarUnPrestecMoltVencut() {
        // Marta tenia un prestec que va vencer fa 60 dies (el 19 de gener)
        Prestec prestec = prestecQueVenc(AVUI.minusDays(60));

        LocalDate nova = gestor.renovar(prestec, 15);

        // Esperat per negoci: avui (20 de marc) + 15 dies = 4 d'abril
        assertThat(nova).isEqualTo(LocalDate.of(2026, 4, 4));
    }
}

Expected: 2026-04-04
Actual:   2026-03-20

LocalDate avui = LocalDate.of(2026, 3, 20);
LocalDate novaData = LocalDate.of(2026, 1, 19).plusDays(15);   // = 2026-02-03

if (novaData.isBefore(avui)) {     // 3 de febrer es anterior al 20 de marc -> true
    novaData = avui;               // es queda a AVUI!
}

public LocalDate renovar(Prestec prestec, int dies) {
    if (prestec.getRenovacions() >= MAX_RENOVACIONS) {
        throw new LimitRenovacionsException(prestec.getId());
    }
    if (prestec.getDataDevolucio().isPresent()) {
        throw new PrestecJaRetornatException(prestec.getId());
    }

    LocalDate avui = LocalDate.now(rellotge);

    // La renovacio sempre compta des de la data MES TARDANA entre avui i el
    // venciment actual. Aixi es garanteix que SEMPRE s'afegeixen `dies` complets
    // de prestec util, tant si el prestec esta en termini com si esta vencut.
    LocalDate base = prestec.getDataVenciment().isAfter(avui)
            ? prestec.getDataVenciment()
            : avui;

    LocalDate novaData = base.plusDays(dies);

    prestec.actualitzarVenciment(novaData);
    prestec.incrementarRenovacions();
    return novaData;
}