try (Recurso r = new Recurso()) {
    // usar r
}
// r ya esta cerrado aqui, pase lo que pase

// ANTES DE JAVA 7: gestion manual
public int contarLineas(String ruta) throws IOException {
    BufferedReader lector = null;              // 1. declarar fuera
    try {
        lector = new BufferedReader(new FileReader(ruta));
        int lineas = 0;
        while (lector.readLine() != null) {
            lineas++;
        }
        return lineas;
    } finally {
        if (lector != null) {                  // 2. comprobar null
            try {
                lector.close();                // 3. close() lanza IOException
            } catch (IOException eCierre) {
                // 4. no relanzar: perderiamos la excepcion original
                System.err.println("Aviso: " + eCierre.getMessage());
            }
        }
    }
}

// DESDE JAVA 7: gestion automatica
public int contarLineas(String ruta) throws IOException {
    try (BufferedReader lector = new BufferedReader(new FileReader(ruta))) {
        int lineas = 0;
        while (lector.readLine() != null) {
            lineas++;
        }
        return lineas;
    }
}

// Lo que el compilador genera (esquema simplificado)
BufferedReader lector = new BufferedReader(new FileReader(ruta));
Throwable excepcionPrincipal = null;
try {
    // ... cuerpo del try ...
} catch (Throwable t) {
    excepcionPrincipal = t;
    throw t;
} finally {
    if (lector != null) {
        if (excepcionPrincipal != null) {
            try {
                lector.close();
            } catch (Throwable tCierre) {
                excepcionPrincipal.addSuppressed(tCierre);   // <-- la clave
            }
        } else {
            lector.close();          // sin excepcion previa: si esta lanza, se propaga
        }
    }
}

// Java 7, java.lang
public interface AutoCloseable {
    void close() throws Exception;
}

// Java 5, java.io
public interface Closeable extends AutoCloseable {
    void close() throws IOException;
}

// close() declara Exception: el usuario tiene que capturar Exception, demasiado ancho
class SesionAmplia implements AutoCloseable {
    @Override
    public void close() throws Exception { }
}

try (SesionAmplia s = new SesionAmplia()) {
    // ...
} catch (Exception e) {          // obligado a capturar Exception: horrible
    // ...
}

// BIEN: close() sin throws. Quien lo use no tendra que capturar nada.
class SesionLimpia implements AutoCloseable {
    @Override
    public void close() {            // sin throws: mas restrictivo, perfectamente legal
        // liberar recursos sin lanzar
    }
}

try (SesionLimpia s = new SesionLimpia()) {
    // ...
}
// Sin catch obligatorio. Mucho mejor.

package com.nexussoftware.bibliotech.presentacion;

/**
 * Demuestra el orden de apertura y de cierre con tres recursos.
 * Los recursos son simulados: no hay E/S real, para que el foco este
 * exclusivamente en el ORDEN.
 */
public class OrdenDeCierre {

    /** Recurso de juguete que anuncia su apertura y su cierre. */
    static class RecursoTrazado implements AutoCloseable {
        private final String nombre;

        RecursoTrazado(String nombre) {
            this.nombre = nombre;
            System.out.println("  ABRIR  " + nombre);
        }

        void usar() {
            System.out.println("  USAR   " + nombre);
        }

        @Override
        public void close() {                  // sin throws: mas comodo para quien lo use
            System.out.println("  CERRAR " + nombre);
        }
    }

    public static void main(String[] args) {
        System.out.println("=== Sin excepcion ===");
        try (RecursoTrazado a = new RecursoTrazado("A-fichero");
             RecursoTrazado b = new RecursoTrazado("B-buffer");
             RecursoTrazado c = new RecursoTrazado("C-parser")) {

            a.usar();
            b.usar();
            c.usar();
        }

        System.out.println("\n=== Con excepcion en el cuerpo ===");
        try (RecursoTrazado a = new RecursoTrazado("A-fichero");
             RecursoTrazado b = new RecursoTrazado("B-buffer")) {

            a.usar();
            throw new IllegalStateException("fallo en mitad del proceso");

        } catch (IllegalStateException e) {
            System.out.println("  CATCH  " + e.getMessage());
        }

        System.out.println("\n=== Con excepcion al ABRIR el segundo recurso ===");
        try (RecursoTrazado a = new RecursoTrazado("A-fichero");
             RecursoTrazado b = crearQueFalla("B-buffer")) {
            a.usar();
        } catch (IllegalStateException e) {
            System.out.println("  CATCH  " + e.getMessage());
        }
    }

    static RecursoTrazado crearQueFalla(String nombre) {
        throw new IllegalStateException("no se pudo abrir " + nombre);
    }
}

=== Sin excepcion ===
  ABRIR  A-fichero
  ABRIR  B-buffer
  ABRIR  C-parser
  USAR   A-fichero
  USAR   B-buffer
  USAR   C-parser
  CERRAR C-parser
  CERRAR B-buffer
  CERRAR A-fichero

=== Con excepcion en el cuerpo ===
  ABRIR  A-fichero
  ABRIR  B-buffer
  USAR   A-fichero
  CERRAR B-buffer
  CERRAR A-fichero
  CATCH  fallo en mitad del proceso

=== Con excepcion al ABRIR el segundo recurso ===
  ABRIR  A-fichero
  CERRAR A-fichero
  CATCH  no se pudo abrir B-buffer

try (BufferedReader lector = new BufferedReader(new FileReader("catalogo.txt"))) {
    lector = new BufferedReader(new FileReader("otro.txt"));   // NO COMPILA
    // error: auto-closeable resource lector may not be assigned
}

try (final BufferedReader lector = new BufferedReader(new FileReader(ruta))) {
    // ...
}

try (RecursoTrazado r = new RecursoTrazado("A")) {
    r.usar();
} catch (Exception e) {
    r.usar();                      // NO COMPILA: cannot find symbol
} finally {
    r.usar();                      // NO COMPILA: cannot find symbol
}

// Java 7/8: hay que crear una variable nueva solo para poder usarla
public void procesar(BufferedReader lectorRecibido) throws IOException {
    try (BufferedReader lector = lectorRecibido) {     // variable redundante
        System.out.println(lector.readLine());
    }
}

// Java 9+: se usa la variable tal cual
public void procesar(BufferedReader lectorRecibido) throws IOException {
    try (lectorRecibido) {                             // sin declaracion nueva
        System.out.println(lectorRecibido.readLine());
    }
}

public void demo() throws Exception {
    RecursoTrazado a = new RecursoTrazado("A");    // efectivamente final: nunca se reasigna
    RecursoTrazado b = new RecursoTrazado("B");

    try (a; b) {                                    // varios, separados por ;
        a.usar();
        b.usar();
    }
    // Se cierran B y luego A
}

RecursoTrazado r = new RecursoTrazado("A");
r = new RecursoTrazado("B");                        // reasignada: ya no es efectivamente final

try (r) {                                            // NO COMPILA
    // error: local variables referenced from a resource specification
    //        must be final or effectively final
}

// SOSPECHOSO: cierro algo que no he abierto yo
public void procesar(BufferedReader lector) throws IOException {
    try (lector) {                     // ¿tengo derecho a cerrarlo?
        // ...
    }
}
// Quien llame no podra volver a usar su lector, y quiza no lo esperaba.

package com.nexussoftware.bibliotech.presentacion;

/**
 * Compara que ocurre cuando fallan el cuerpo Y el cierre:
 *  - con try-finally manual: la excepcion del cierre SUSTITUYE a la original.
 *  - con try-with-resources: la original se conserva y la del cierre queda SUPRIMIDA.
 */
public class ExcepcionesSuprimidas {

    /** Recurso cuyo cierre tambien falla. */
    static class RecursoFragil implements AutoCloseable {
        private final String nombre;

        RecursoFragil(String nombre) {
            this.nombre = nombre;
        }

        void leer() {
            throw new IllegalStateException("FALLO REAL: " + nombre + " esta corrupto");
        }

        @Override
        public void close() {
            throw new IllegalStateException("FALLO AL CERRAR: no se libero " + nombre);
        }
    }

    public static void main(String[] args) {

        System.out.println("=== A) try-finally MANUAL ===");
        try {
            conFinallyManual();
        } catch (IllegalStateException e) {
            System.out.println("  Recibida  : " + e.getMessage());
            System.out.println("  Causa     : " + e.getCause());
            System.out.println("  Suprimidas: " + e.getSuppressed().length);
            System.out.println("  >> El FALLO REAL ha desaparecido");
        }

        System.out.println("\n=== B) try-with-resources ===");
        try {
            conTryWithResources();
        } catch (IllegalStateException e) {
            System.out.println("  Recibida  : " + e.getMessage());
            System.out.println("  Causa     : " + e.getCause());
            System.out.println("  Suprimidas: " + e.getSuppressed().length);
            for (Throwable suprimida : e.getSuppressed()) {
                System.out.println("    - " + suprimida.getMessage());
            }
            System.out.println("  >> Se conservan LAS DOS");
        }

        System.out.println("\n=== C) Solo falla el cierre ===");
        try {
            soloFallaElCierre();
        } catch (IllegalStateException e) {
            System.out.println("  Recibida  : " + e.getMessage());
            System.out.println("  Suprimidas: " + e.getSuppressed().length);
            System.out.println("  >> Sin excepcion previa, la del cierre se propaga normal");
        }
    }

    static void conFinallyManual() {
        RecursoFragil recurso = new RecursoFragil("catalogo.txt");
        try {
            recurso.leer();
        } finally {
            recurso.close();          // esta excepcion SUSTITUYE a la del try
        }
    }

    static void conTryWithResources() {
        try (RecursoFragil recurso = new RecursoFragil("catalogo.txt")) {
            recurso.leer();
        }
    }

    static void soloFallaElCierre() {
        try (RecursoFragil recurso = new RecursoFragil("prestamos.txt")) {
            System.out.println("  (el cuerpo termina bien)");
        }
    }
}

=== A) try-finally MANUAL ===
  Recibida  : FALLO AL CERRAR: no se libero catalogo.txt
  Causa     : null
  Suprimidas: 0
  >> El FALLO REAL ha desaparecido

=== B) try-with-resources ===
  Recibida  : FALLO REAL: catalogo.txt esta corrupto
  Causa     : null
  Suprimidas: 1
    - FALLO AL CERRAR: no se libero catalogo.txt
  >> Se conservan LAS DOS

=== C) Solo falla el cierre ===
  (el cuerpo termina bien)
  Recibida  : FALLO AL CERRAR: no se libero prestamos.txt
  Suprimidas: 0
  >> Sin excepcion previa, la del cierre se propaga normal

Exception in thread "main" java.lang.IllegalStateException: FALLO REAL: catalogo.txt esta corrupto
	at com.nexussoftware.bibliotech.presentacion.ExcepcionesSuprimidas$RecursoFragil.leer(ExcepcionesSuprimidas.java:22)
	at com.nexussoftware.bibliotech.presentacion.ExcepcionesSuprimidas.conTryWithResources(ExcepcionesSuprimidas.java:70)
	at com.nexussoftware.bibliotech.presentacion.ExcepcionesSuprimidas.main(ExcepcionesSuprimidas.java:38)
	Suppressed: java.lang.IllegalStateException: FALLO AL CERRAR: no se libero catalogo.txt
		at com.nexussoftware.bibliotech.presentacion.ExcepcionesSuprimidas$RecursoFragil.close(ExcepcionesSuprimidas.java:27)
		at com.nexussoftware.bibliotech.presentacion.ExcepcionesSuprimidas.conTryWithResources(ExcepcionesSuprimidas.java:71)
		... 1 more

package com.nexussoftware.bibliotech.presentacion;

/** Vuelca una excepcion con sus causas y sus suprimidas, indentadas. */
public final class InformeExcepcion {

    private InformeExcepcion() { }

    public static String describir(Throwable t) {
        StringBuilder sb = new StringBuilder();
        describir(t, sb, 0, "");
        return sb.toString();
    }

    private static void describir(Throwable t, StringBuilder sb, int nivel, String etiqueta) {
        if (t == null || nivel > 10) {                 // proteccion anticircular
            return;
        }
        String sangria = "  ".repeat(nivel);
        sb.append(sangria).append(etiqueta)
          .append(t.getClass().getSimpleName()).append(": ")
          .append(t.getMessage() != null ? t.getMessage() : "(sin mensaje)")
          .append('\n');

        // Primer marco propio, para situar el fallo
        for (StackTraceElement m : t.getStackTrace()) {
            if (m.getClassName().startsWith("com.nexussoftware")) {
                sb.append(sangria).append("    en ").append(m.getMethodName())
                  .append(" (").append(m.getFileName()).append(':')
                  .append(m.getLineNumber()).append(")\n");
                break;
            }
        }

        // Suprimidas: ocurrieron ADEMAS (mismo nivel logico, indentadas)
        for (Throwable suprimida : t.getSuppressed()) {
            describir(suprimida, sb, nivel + 1, "Suppressed: ");
        }

        // Causa: PROVOCO la anterior
        if (t.getCause() != null && t.getCause() != t) {
            describir(t.getCause(), sb, nivel + 1, "Caused by: ");
        }
    }
}

// Legal: try-with-resources sin catch ni finally
try (RecursoTrazado r = new RecursoTrazado("A")) {
    r.usar();
}

// Legal: con catch
try (RecursoTrazado r = new RecursoTrazado("A")) {
    r.usar();
} catch (IllegalStateException e) {
    System.out.println("Fallo: " + e.getMessage());
}

// Legal: con catch y finally
try (RecursoTrazado r = new RecursoTrazado("A")) {
    r.usar();
} catch (IllegalStateException e) {
    System.out.println("Fallo: " + e.getMessage());
} finally {
    System.out.println("Limpieza adicional, no relacionada con recursos");
}

package com.nexussoftware.bibliotech.presentacion;

public class OrdenCompleto {

    static class Recurso implements AutoCloseable {
        Recurso() { System.out.println("1. abrir"); }
        void usar() { throw new IllegalStateException("fallo en el cuerpo"); }
        @Override public void close() { System.out.println("3. cerrar"); }
    }

    public static void main(String[] args) {
        try (Recurso r = new Recurso()) {
            System.out.println("2. cuerpo");
            r.usar();
        } catch (IllegalStateException e) {
            System.out.println("4. catch: " + e.getMessage());
        } finally {
            System.out.println("5. finally");
        }
        System.out.println("6. despues");
    }
}

1. abrir
2. cuerpo
3. cerrar
4. catch: fallo en el cuerpo
5. finally
6. despues

// PROBLEMA REAL: cierra System.in para TODA la aplicacion
public int leerOpcion() {
    try (Scanner scanner = new Scanner(System.in)) {     // MAL
        return Integer.parseInt(scanner.nextLine());
    }
}

// A partir de aqui, cualquier otro Scanner sobre System.in falla:
// NoSuchElementException: No line found

// CORRECTO: un unico Scanner de instancia, sin try-with-resources
public class MenuBiblioTech {

    private final Scanner scanner = new Scanner(System.in);   // se crea una vez

    public int leerOpcion() {
        // Sin try-with-resources: System.in NO se cierra
        return Integer.parseInt(scanner.nextLine().trim());
    }
    // No se cierra nunca: System.in lo cierra la JVM al terminar el proceso
}

// MAL: se cierra el recurso justo antes de devolverlo
public BufferedReader abrirCatalogo(String ruta) throws IOException {
    try (BufferedReader lector = new BufferedReader(new FileReader(ruta))) {
        return lector;             // se cierra ANTES de retornar (06-05: el finally corre primero)
    }
}
// Quien lo reciba obtendra "Stream closed" en la primera lectura.

public class MiRecurso implements AutoCloseable {

    private boolean cerrado = false;

    public MiRecurso() {
        // adquirir lo que haga falta
    }

    public void operacion() {
        comprobarAbierto();          // proteger frente al uso tras el cierre
        // ...
    }

    private void comprobarAbierto() {
        if (cerrado) {
            throw new IllegalStateException("El recurso ya esta cerrado");
        }
    }

    @Override
    public void close() {            // sin throws: mas comodo para quien lo use
        if (cerrado) {
            return;                  // IDEMPOTENTE: cerrar dos veces no falla
        }
        cerrado = true;
        // liberar lo adquirido
    }
}

try (MiRecurso r = new MiRecurso()) {
    r.operacion();
    r.close();                // cierre explicito anticipado
}                             // ...y el try-with-resources lo cierra OTRA VEZ

@Override
public void close() {
    if (cerrado) { return; }
    cerrado = true;
    try {
        liberarRecursoSubyacente();
    } catch (RuntimeException e) {
        // Se registra, no se propaga: cerrar no debe romper una operacion correcta.
        // En 06-07 esto sera logger.log(Level.WARNING, "...", e).
        System.err.println("Aviso: fallo al liberar el recurso: " + e.getMessage());
    }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * Turno de trabajo de un empleado sobre BiblioTech.
 *
 * Al cerrarse:
 *   1. consolida las estadisticas del turno,
 *   2. libera el bloqueo del catalogo,
 *   3. deja la sesion inutilizable.
 *
 * Implementa AutoCloseable, no Closeable, porque no es un recurso de E/S.
 * Y su close() NO declara throws: asi quien la use no esta obligado a capturar nada.
 */
public class SesionBiblioteca implements AutoCloseable {

    private final String idEmpleado;
    private final int diaApertura;
    private final Catalogo catalogo;

    private final List<String> operaciones = new ArrayList<>();
    private int prestamosRealizados = 0;
    private int devolucionesRealizadas = 0;
    private double multasCobradas = 0.0;

    private boolean cerrada = false;

    /** Estadisticas acumuladas de todos los turnos (estaticas: 03-02). */
    private static int turnosCompletados = 0;
    private static int operacionesTotales = 0;

    public SesionBiblioteca(String idEmpleado, int diaApertura, Catalogo catalogo) {
        this.idEmpleado = Objects.requireNonNull(idEmpleado, "El empleado no puede ser nulo");
        this.catalogo = Objects.requireNonNull(catalogo, "El catalogo no puede ser nulo");
        if (diaApertura < 1) {
            throw new IllegalArgumentException("El dia debe ser 1 o posterior, y era: " + diaApertura);
        }
        this.diaApertura = diaApertura;

        catalogo.bloquear(idEmpleado);          // adquisicion del recurso
        System.out.println("  [sesion de " + idEmpleado + " abierta el dia " + diaApertura + "]");
    }

    // ---------- Operaciones del turno ----------

    public void anotarPrestamo(String referencia) {
        comprobarAbierta();
        prestamosRealizados++;
        operaciones.add("PRESTAMO " + referencia);
    }

    public void anotarDevolucion(String referencia, double multa) {
        comprobarAbierta();
        if (multa < 0) {
            throw new IllegalArgumentException("La multa no puede ser negativa: " + multa);
        }
        devolucionesRealizadas++;
        multasCobradas += multa;
        operaciones.add(String.format("DEVOLUCION %s (multa %.2f)", referencia, multa));
    }

    public List<String> getOperaciones() {
        comprobarAbierta();
        return List.copyOf(operaciones);
    }

    /**
     * Todos los metodos de uso comprueban el estado.
     * Es IllegalStateException, no IllegalArgumentException: el problema
     * es CUANDO se pide, no que se pide (06-03).
     */
    private void comprobarAbierta() {
        if (cerrada) {
            throw new IllegalStateException(
                    "La sesion de " + idEmpleado + " ya esta cerrada");
        }
    }

    // ---------- Cierre ----------

    /**
     * Consolida y libera. IDEMPOTENTE y sin throws comprobado.
     *
     * Se ejecuta con exito y con fallo del cuerpo, porque el try-with-resources
     * lo garantiza igual que un finally (06-05).
     */
    @Override
    public void close() {
        if (cerrada) {
            return;                              // idempotente
        }
        cerrada = true;

        // 1. Consolidar estadisticas
        turnosCompletados++;
        operacionesTotales += operaciones.size();

        System.out.printf("  [sesion de %s cerrada] %d prestamos, %d devoluciones, %.2f EUR%n",
                idEmpleado, prestamosRealizados, devolucionesRealizadas, multasCobradas);

        // 2. Liberar el bloqueo, protegido para no romper una operacion correcta
        try {
            catalogo.desbloquear(idEmpleado);
        } catch (RuntimeException e) {
            // No se propaga: cerrar no debe convertir un turno correcto en un fallo.
            // En 06-07 esto sera logger.log(Level.WARNING, ..., e).
            System.err.println("  Aviso: no se pudo liberar el bloqueo del catalogo: "
                    + e.getMessage());
        }
    }

    public boolean estaCerrada() { return cerrada; }

    public static int getTurnosCompletados()  { return turnosCompletados; }
    public static int getOperacionesTotales() { return operacionesTotales; }
}

package com.nexussoftware.bibliotech.servicio;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.List;

import com.nexussoftware.bibliotech.dominio.Material;

/**
 * Exporta el catalogo a un fichero de texto.
 *
 * Implementa Closeable (no AutoCloseable) porque ES un recurso de E/S y su
 * close() puede lanzar IOException legitimamente: al cerrar se vacia el
 * buffer al disco, y si eso falla, los datos NO se han escrito. Ese fallo
 * SI debe llegar al llamador.
 *
 * (La API de escritura se desarrolla en el modulo 7.)
 */
public class ExportadorCatalogo implements java.io.Closeable {

    private final String ruta;
    private final BufferedWriter escritor;

    private int materialesEscritos = 0;
    private boolean cerrado = false;

    public ExportadorCatalogo(String ruta) throws IOException {
        this.ruta = ruta;
        this.escritor = new BufferedWriter(new FileWriter(ruta));
        escribirCabecera();
    }

    private void escribirCabecera() throws IOException {
        escritor.write("# Catalogo de BiblioTech - Nexus Software");
        escritor.newLine();
        escritor.write("# referencia;titulo;disponible");
        escritor.newLine();
    }

    public void exportar(Material material) throws IOException {
        if (cerrado) {
            throw new IllegalStateException("El exportador de '" + ruta + "' ya esta cerrado");
        }
        escritor.write(material.getReferencia() + ";" + material.getTitulo() + ";"
                + material.estaDisponible());
        escritor.newLine();
        materialesEscritos++;
    }

    public void exportarTodos(List<Material> materiales) throws IOException {
        for (Material m : materiales) {
            exportar(m);
        }
    }

    public int getMaterialesEscritos() { return materialesEscritos; }

    /**
     * Cierra el fichero.
     *
     * AQUI SI se propaga la IOException: el close() de un escritor vacia el
     * buffer al disco. Si falla, los datos no estan guardados y quien llama
     * tiene que enterarse. Es la excepcion a la regla de "close no lanza".
     */
    @Override
    public void close() throws IOException {
        if (cerrado) {
            return;                              // idempotente
        }
        cerrado = true;
        try {
            escritor.write("# Total: " + materialesEscritos + " materiales");
            escritor.newLine();
        } finally {
            escritor.close();                    // vacia el buffer y libera el descriptor
        }
    }
}

package com.nexussoftware.bibliotech.presentacion;

import java.io.IOException;

import com.nexussoftware.bibliotech.dominio.Libro;
import com.nexussoftware.bibliotech.servicio.Catalogo;
import com.nexussoftware.bibliotech.servicio.ExportadorCatalogo;
import com.nexussoftware.bibliotech.servicio.SesionBiblioteca;

public class DemoSesionYExportador {

    public static void main(String[] args) {
        Catalogo catalogo = new Catalogo();
        catalogo.registrar(new Libro("LIB-0001", "Java Efectivo", "Bloch", 2018, "978-0000000001"));
        catalogo.registrar(new Libro("LIB-0002", "Patrones de Diseno", "GoF", 1994, "978-0000000002"));
        catalogo.registrar(new Libro("LIB-0003", "Refactorizacion", "Fowler", 1999, "978-0000000003"));

        // === 1. Turno que va bien ===
        System.out.println("=== 1. Turno correcto de Marta ===");
        try (SesionBiblioteca sesion = new SesionBiblioteca("EMP-001", 10, catalogo)) {
            sesion.anotarPrestamo("LIB-0001");
            sesion.anotarPrestamo("LIB-0002");
            sesion.anotarDevolucion("LIB-0003", 1.25);
            System.out.println("  Operaciones del turno: " + sesion.getOperaciones());
        }
        System.out.println("  Catalogo bloqueado: " + catalogo.estaBloqueado());

        // === 2. Turno que falla a mitad ===
        System.out.println("\n=== 2. Turno de Diego que falla ===");
        try (SesionBiblioteca sesion = new SesionBiblioteca("EMP-002", 11, catalogo)) {
            sesion.anotarPrestamo("LIB-0001");
            sesion.anotarDevolucion("LIB-0002", -5.0);        // lanza
            System.out.println("  esta linea no se ejecuta");
        } catch (IllegalArgumentException e) {
            System.out.println("  Fallo capturado: " + e.getMessage());
        }
        System.out.println("  Catalogo bloqueado: " + catalogo.estaBloqueado());
        System.out.println("  (la sesion se cerro y consolido igualmente)");

        // === 3. Usar la sesion despues de cerrarla ===
        System.out.println("\n=== 3. Uso tras el cierre ===");
        SesionBiblioteca fuera;
        try (SesionBiblioteca sesion = new SesionBiblioteca("EMP-003", 12, catalogo)) {
            sesion.anotarPrestamo("LIB-0003");
            fuera = sesion;                                   // se guarda la referencia
        }
        try {
            fuera.anotarPrestamo("LIB-0001");
        } catch (IllegalStateException e) {
            System.out.println("  " + e.getMessage());
        }
        System.out.println("  close() dos veces: ");
        fuera.close();                                        // idempotente: no falla
        System.out.println("  sin errores");

        // === 4. Dos recursos anidados ===
        System.out.println("\n=== 4. Sesion + exportador (dos recursos) ===");
        try (SesionBiblioteca sesion = new SesionBiblioteca("EMP-001", 13, catalogo);
             ExportadorCatalogo exportador = new ExportadorCatalogo("catalogo-export.txt")) {

            exportador.exportarTodos(catalogo.listar());
            sesion.anotarPrestamo("LIB-0002");
            System.out.println("  Exportados: " + exportador.getMaterialesEscritos());

        } catch (IOException e) {
            System.out.println("  Fallo de exportacion: " + e.getMessage());
        }
        // Cierre en orden INVERSO: primero el exportador, luego la sesion

        System.out.println("\n=== Estadisticas globales ===");
        System.out.println("  Turnos completados : " + SesionBiblioteca.getTurnosCompletados());
        System.out.println("  Operaciones totales: " + SesionBiblioteca.getOperacionesTotales());
    }
}

=== 1. Turno correcto de Marta ===
  [sesion de EMP-001 abierta el dia 10]
  Operaciones del turno: [PRESTAMO LIB-0001, PRESTAMO LIB-0002, DEVOLUCION LIB-0003 (multa 1,25)]
  [sesion de EMP-001 cerrada] 2 prestamos, 1 devoluciones, 1,25 EUR
  Catalogo bloqueado: false

=== 2. Turno de Diego que falla ===
  [sesion de EMP-002 abierta el dia 11]
  [sesion de EMP-002 cerrada] 1 prestamos, 0 devoluciones, 0,00 EUR
  Fallo capturado: La multa no puede ser negativa: -5.0
  Catalogo bloqueado: false
  (la sesion se cerro y consolido igualmente)

=== 3. Uso tras el cierre ===
  [sesion de EMP-003 abierta el dia 12]
  [sesion de EMP-003 cerrada] 1 prestamos, 0 devoluciones, 0,00 EUR
  La sesion de EMP-003 ya esta cerrada
  close() dos veces:
  sin errores

=== 4. Sesion + exportador (dos recursos) ===
  [sesion de EMP-001 abierta el dia 13]
  Exportados: 3
  [sesion de EMP-001 cerrada] 1 prestamos, 0 devoluciones, 0,00 EUR

=== Estadisticas globales ===
  Turnos completados : 4
  Operaciones totales: 5

package com.nexussoftware.bibliotech.servicio;

import java.util.Objects;

/**
 * Bloqueo de exclusion sobre el catalogo, reentrante y cerrable.
 *
 * Uso previsto:
 *   try (BloqueoCatalogo b = new BloqueoCatalogo("EMP-001")) {
 *       // operaciones exclusivas
 *   }   // liberado siempre
 *
 * Nota: esto NO es seguro para concurrencia; los bloqueos reales entre
 * hilos son materia del modulo 8. Aqui es un bloqueo logico de un solo hilo.
 */
public class BloqueoCatalogo implements AutoCloseable {

    private static String propietarioActual = null;
    private static int profundidad = 0;
    private static int bloqueosConcedidos = 0;
    private static int contadorMomentos = 0;

    private final String idPropietario;
    private final int momentoAdquisicion;
    private final boolean esReentrada;

    private boolean cerrado = false;

    /**
     * Adquiere el bloqueo.
     *
     * @throws IllegalStateException si lo tiene OTRO propietario
     */
    public BloqueoCatalogo(String idPropietario) {
        this.idPropietario = Objects.requireNonNull(idPropietario,
                "El identificador del propietario no puede ser nulo");

        if (propietarioActual != null && !propietarioActual.equals(idPropietario)) {
            throw new IllegalStateException(
                    "El catalogo esta bloqueado por " + propietarioActual
                            + "; " + idPropietario + " no puede adquirirlo");
        }

        this.esReentrada = (propietarioActual != null);   // mismo propietario otra vez
        propietarioActual = idPropietario;
        profundidad++;
        bloqueosConcedidos++;
        this.momentoAdquisicion = ++contadorMomentos;

        System.out.println("    [bloqueo " + (esReentrada ? "REENTRANTE " : "")
                + "adquirido por " + idPropietario + " (profundidad " + profundidad
                + ", momento " + momentoAdquisicion + ")]");
    }

    /**
     * Libera el bloqueo. Solo lo libera DE VERDAD el mas externo.
     * Idempotente: cerrar dos veces no hace nada la segunda.
     */
    @Override
    public void close() {
        if (cerrado) {
            return;                              // idempotente
        }
        cerrado = true;
        profundidad--;

        if (profundidad == 0) {
            propietarioActual = null;
            System.out.println("    [bloqueo LIBERADO por " + idPropietario + "]");
        } else {
            System.out.println("    [nivel reentrante cerrado; profundidad " + profundidad + "]");
        }
    }

    /**
     * Comprueba que quien opera es el propietario del bloqueo.
     *
     * @throws IllegalStateException si no lo es, o si no hay bloqueo
     */
    public static void comprobarPropiedad(String id) {
        if (propietarioActual == null) {
            throw new IllegalStateException(
                    "No hay ningun bloqueo activo sobre el catalogo; " + id + " no puede operar");
        }
        if (!propietarioActual.equals(id)) {
            throw new IllegalStateException(
                    "El catalogo esta bloqueado por " + propietarioActual + ", no por " + id);
        }
    }

    public String getIdPropietario()   { return idPropietario; }
    public int getMomentoAdquisicion() { return momentoAdquisicion; }
    public boolean estaCerrado()       { return cerrado; }

    public static String getPropietarioActual() { return propietarioActual; }
    public static int getProfundidad()          { return profundidad; }
    public static int getBloqueosConcedidos()   { return bloqueosConcedidos; }

    // ------------------------------------------------------------------

    public static void main(String[] args) {

        System.out.println("=== 1. Adquisicion y liberacion normal ===");
        try (BloqueoCatalogo b = new BloqueoCatalogo("EMP-001")) {
            System.out.println("  operando como " + b.getIdPropietario());
            comprobarPropiedad("EMP-001");
        }
        System.out.println("  Propietario tras cerrar: " + getPropietarioActual());

        System.out.println("\n=== 2. Reentrancia de dos niveles ===");
        try (BloqueoCatalogo externo = new BloqueoCatalogo("EMP-001")) {
            System.out.println("  nivel externo");

            try (BloqueoCatalogo interno = new BloqueoCatalogo("EMP-001")) {
                System.out.println("  nivel interno");
                System.out.println("  Profundidad dentro: " + getProfundidad());
            }
            System.out.println("  Tras cerrar el interno, profundidad: " + getProfundidad());
            System.out.println("  Propietario sigue siendo: " + getPropietarioActual());
        }
        System.out.println("  Tras cerrar el externo: " + getPropietarioActual());

        System.out.println("\n=== 3. Otro empleado intenta bloquear ===");
        try (BloqueoCatalogo b = new BloqueoCatalogo("EMP-001")) {
            try (BloqueoCatalogo otro = new BloqueoCatalogo("EMP-002")) {
                System.out.println("  esto no deberia ocurrir");
            } catch (IllegalStateException e) {
                System.out.println("  Rechazado: " + e.getMessage());
            }
            System.out.println("  El bloqueo de EMP-001 sigue vivo: " + getPropietarioActual());
        }

        System.out.println("\n=== 4. Excepcion en el cuerpo ===");
        try (BloqueoCatalogo b = new BloqueoCatalogo("EMP-003")) {
            System.out.println("  operando...");
            throw new IllegalArgumentException("fallo en mitad de la operacion");
        } catch (IllegalArgumentException e) {
            System.out.println("  Excepcion recibida INTACTA: " + e.getMessage());
        }
        System.out.println("  Propietario tras el fallo: " + getPropietarioActual()
                + " (liberado correctamente)");

        System.out.println("\n=== 5. close() doble ===");
        BloqueoCatalogo manual = new BloqueoCatalogo("EMP-001");
        manual.close();
        manual.close();
        System.out.println("  Sin errores. Profundidad: " + getProfundidad());

        System.out.println("\n=== 6. Operar sin bloqueo ===");
        try {
            comprobarPropiedad("EMP-002");
        } catch (IllegalStateException e) {
            System.out.println("  " + e.getMessage());
        }

        System.out.println("\nBloqueos concedidos en total: " + getBloqueosConcedidos());
    }
}

=== 1. Adquisicion y liberacion normal ===
    [bloqueo adquirido por EMP-001 (profundidad 1, momento 1)]
  operando como EMP-001
    [bloqueo LIBERADO por EMP-001]
  Propietario tras cerrar: null

=== 2. Reentrancia de dos niveles ===
    [bloqueo adquirido por EMP-001 (profundidad 1, momento 2)]
  nivel externo
    [bloqueo REENTRANTE adquirido por EMP-001 (profundidad 2, momento 3)]
  nivel interno
  Profundidad dentro: 2
    [nivel reentrante cerrado; profundidad 1]
  Tras cerrar el interno, profundidad: 1
  Propietario sigue siendo: EMP-001
    [bloqueo LIBERADO por EMP-001]
  Tras cerrar el externo: null

=== 3. Otro empleado intenta bloquear ===
    [bloqueo adquirido por EMP-001 (profundidad 1, momento 4)]
  Rechazado: El catalogo esta bloqueado por EMP-001; EMP-002 no puede adquirirlo
  El bloqueo de EMP-001 sigue vivo: EMP-001
    [bloqueo LIBERADO por EMP-001]

=== 4. Excepcion en el cuerpo ===
    [bloqueo adquirido por EMP-003 (profundidad 1, momento 5)]
  operando...
    [bloqueo LIBERADO por EMP-003]
  Excepcion recibida INTACTA: fallo en mitad de la operacion
  Propietario tras el fallo: null (liberado correctamente)

=== 5. close() doble ===
    [bloqueo adquirido por EMP-001 (profundidad 1, momento 6)]
    [bloqueo LIBERADO por EMP-001]
  Sin errores. Profundidad: 0

=== 6. Operar sin bloqueo ===
  No hay ningun bloqueo activo sobre el catalogo; EMP-002 no puede operar

Bloqueos concedidos en total: 6

package com.nexussoftware.bibliotech.presentacion;

/**
 * Explora el mecanismo de excepciones suprimidas con tres recursos.
 */
public class CascadaDeFallos {

    static class RecursoQueFalla implements AutoCloseable {
        private final String nombre;
        private final boolean fallaAlUsar;
        private final boolean fallaAlCerrar;

        RecursoQueFalla(String nombre, boolean fallaAlUsar, boolean fallaAlCerrar) {
            this(nombre, fallaAlUsar, fallaAlCerrar, false);
        }

        RecursoQueFalla(String nombre, boolean fallaAlUsar, boolean fallaAlCerrar,
                        boolean fallaAlAbrir) {
            if (fallaAlAbrir) {
                throw new IllegalStateException("APERTURA fallida de " + nombre);
            }
            this.nombre = nombre;
            this.fallaAlUsar = fallaAlUsar;
            this.fallaAlCerrar = fallaAlCerrar;
            System.out.println("    abrir  " + nombre);
        }

        void usar() {
            System.out.println("    usar   " + nombre);
            if (fallaAlUsar) {
                throw new IllegalStateException("USO fallido de " + nombre);
            }
        }

        @Override
        public void close() {
            System.out.println("    cerrar " + nombre);
            if (fallaAlCerrar) {
                throw new IllegalStateException("CIERRE fallido de " + nombre);
            }
        }
    }

    public static void main(String[] args) {

        escenario("1. Nada falla", false, false, false, false, false, false);
        escenario("2. Falla solo el cuerpo", true, false, false, false, false, false);
        escenario("3. Falla solo el cierre del central", false, false, false, false, true, false);
        escenario("4. Falla el cuerpo Y los tres cierres", true, false, false, true, true, true);
        escenarioAperturaFallida();
    }

    /**
     * @param fallaCuerpo     si el cuerpo lanza tras usar los recursos
     * @param cierre1/2/3     si falla el cierre de cada recurso
     */
    static void escenario(String titulo, boolean fallaCuerpo,
                          boolean usoA, boolean usoB,
                          boolean cierre1, boolean cierre2, boolean cierre3) {
        System.out.println("\n=== " + titulo + " ===");
        try (RecursoQueFalla r1 = new RecursoQueFalla("R1", usoA, cierre1);
             RecursoQueFalla r2 = new RecursoQueFalla("R2", usoB, cierre2);
             RecursoQueFalla r3 = new RecursoQueFalla("R3", false, cierre3)) {

            r1.usar();
            r2.usar();
            r3.usar();

            if (fallaCuerpo) {
                throw new IllegalStateException("CUERPO fallido");
            }
            System.out.println("  (sin excepcion)");

        } catch (IllegalStateException e) {
            System.out.println("  --- Excepcion propagada ---");
            System.out.println(volcar(e));
        }
    }

    static void escenarioAperturaFallida() {
        System.out.println("\n=== 5. Falla la APERTURA del tercer recurso ===");
        try (RecursoQueFalla r1 = new RecursoQueFalla("R1", false, false);
             RecursoQueFalla r2 = new RecursoQueFalla("R2", false, false);
             RecursoQueFalla r3 = new RecursoQueFalla("R3", false, false, true)) {

            r1.usar();
            System.out.println("  esta linea NO se ejecuta");

        } catch (IllegalStateException e) {
            System.out.println("  --- Excepcion propagada ---");
            System.out.println(volcar(e));
        }
    }

    /** Vuelca el arbol de causas y suprimidas con indentacion. */
    static String volcar(Throwable t) {
        StringBuilder sb = new StringBuilder();
        volcar(t, sb, 1, "");
        return sb.toString();
    }

    private static void volcar(Throwable t, StringBuilder sb, int nivel, String etiqueta) {
        if (t == null || nivel > 10) { return; }

        sb.append("  ".repeat(nivel)).append(etiqueta)
          .append(t.getClass().getSimpleName()).append(": ")
          .append(t.getMessage()).append('\n');

        for (Throwable s : t.getSuppressed()) {
            volcar(s, sb, nivel + 1, "Suppressed: ");
        }
        if (t.getCause() != null && t.getCause() != t) {
            volcar(t.getCause(), sb, nivel + 1, "Caused by: ");
        }
    }
}

=== 1. Nada falla ===
    abrir  R1
    abrir  R2
    abrir  R3
    usar   R1
    usar   R2
    usar   R3
  (sin excepcion)
    cerrar R3
    cerrar R2
    cerrar R1

=== 2. Falla solo el cuerpo ===
    abrir  R1 / R2 / R3 ... usar R1 / R2 / R3
    cerrar R3
    cerrar R2
    cerrar R1
  --- Excepcion propagada ---
    IllegalStateException: CUERPO fallido

=== 3. Falla solo el cierre del central ===
    ... cerrar R3
    cerrar R2
  --- Excepcion propagada ---
    IllegalStateException: CIERRE fallido de R2

=== 4. Falla el cuerpo Y los tres cierres ===
    cerrar R3
    cerrar R2
    cerrar R1
  --- Excepcion propagada ---
    IllegalStateException: CUERPO fallido
      Suppressed: IllegalStateException: CIERRE fallido de R3
      Suppressed: IllegalStateException: CIERRE fallido de R2
      Suppressed: IllegalStateException: CIERRE fallido de R1

=== 5. Falla la APERTURA del tercer recurso ===
    abrir  R1
    abrir  R2
    cerrar R2
    cerrar R1
  --- Excepcion propagada ---
    IllegalStateException: APERTURA fallida de R3

package com.nexussoftware.bibliotech.servicio;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import com.nexussoftware.bibliotech.dominio.Libro;
import com.nexussoftware.bibliotech.dominio.ReferenciaDuplicadaException;

/**
 * Importa materiales desde un fichero de texto al catalogo.
 *
 * NOTA SOBRE LA API DE E/S: aqui solo se usan FileReader, BufferedReader y
 * BufferedWriter para abrir, leer/escribir lineas y cerrar. La entrada/salida
 * completa (flujos, NIO.2, formatos) es el MODULO 7. El foco de esta clase
 * esta en el CIERRE garantizado con try-with-resources.
 */
public class ImportadorCatalogo {

    public record InformeImportacion(int leidas, int aceptadas, int rechazadas,
                                     List<String> motivos) {

        public String resumen() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== INFORME DE IMPORTACION ===\n");
            sb.append("Lineas leidas : ").append(leidas).append('\n');
            sb.append("Aceptadas     : ").append(aceptadas).append('\n');
            sb.append("Rechazadas    : ").append(rechazadas).append('\n');
            for (String m : motivos) {
                sb.append("  * ").append(m).append('\n');
            }
            return sb.toString();
        }
    }

    private final Catalogo catalogo;

    public ImportadorCatalogo(Catalogo catalogo) {
        this.catalogo = catalogo;
    }

    /**
     * Importa un fichero al catalogo.
     *
     * NO captura la IOException de apertura: la declara para que decida el
     * llamador si arranca con catalogo vacio o aborta (06-03).
     */
    public InformeImportacion importar(String ruta) throws IOException {
        List<String> motivos = new ArrayList<>();
        int leidas = 0;
        int aceptadas = 0;

        // try-with-resources: el lector se cierra siempre, incluso si
        // el bucle lanza. Con try-finally manual harian falta 8 lineas mas.
        try (BufferedReader lector = new BufferedReader(new FileReader(ruta))) {

            String linea;
            while ((linea = lector.readLine()) != null) {
                leidas++;

                if (linea.isBlank() || linea.startsWith("#")) {
                    continue;                    // vacias y comentarios: se saltan sin ruido
                }

                // try DENTRO del bucle: una linea mala no aborta la importacion (06-02)
                try {
                    String[] c = linea.split(";");
                    Libro libro = new Libro(c[0].trim(), c[1].trim(), c[2].trim(),
                            Integer.parseInt(c[3].trim()), c[4].trim());
                    catalogo.registrar(libro);
                    aceptadas++;

                } catch (ArrayIndexOutOfBoundsException e) {
                    motivos.add("Linea " + leidas + ": faltan campos -> '" + linea + "'");

                } catch (NumberFormatException e) {
                    motivos.add("Linea " + leidas + ": anio no numerico -> " + e.getMessage());

                } catch (ReferenciaDuplicadaException e) {
                    // Excepcion del DOMINIO (06-04): usa sus datos, no su mensaje
                    motivos.add("Linea " + leidas + ": " + e.getTipo() + " duplicado "
                            + e.getValorDuplicado() + ", ya la usa '"
                            + e.getTituloExistente() + "'");

                } catch (IllegalArgumentException e) {
                    // Validaciones de Libro (formato de referencia, anio, ISBN)
                    motivos.add("Linea " + leidas + ": dato invalido -> " + e.getMessage());
                }
            }
        }
        // El lector ya esta cerrado aqui, con exito o con fallo

        return new InformeImportacion(leidas, aceptadas, leidas - aceptadas, motivos);
    }

    /**
     * Importa dentro de una sesion de trabajo: DOS recursos en el mismo
     * try-with-resources, cerrados en orden inverso al de apertura.
     */
    public InformeImportacion importarConSesion(String ruta, String idEmpleado, int dia)
            throws IOException {

        try (SesionBiblioteca sesion = new SesionBiblioteca(idEmpleado, dia, catalogo);
             BufferedReader lector = new BufferedReader(new FileReader(ruta))) {

            List<String> motivos = new ArrayList<>();
            int leidas = 0;
            int aceptadas = 0;
            String linea;

            while ((linea = lector.readLine()) != null) {
                leidas++;
                if (linea.isBlank() || linea.startsWith("#")) { continue; }

                try {
                    String[] c = linea.split(";");
                    catalogo.registrar(new Libro(c[0].trim(), c[1].trim(), c[2].trim(),
                            Integer.parseInt(c[3].trim()), c[4].trim()));
                    aceptadas++;
                    sesion.anotarPrestamo("ALTA " + c[0].trim());   // se anota en el turno

                } catch (RuntimeException e) {
                    motivos.add("Linea " + leidas + ": " + e.getClass().getSimpleName()
                            + " - " + e.getMessage());
                }
            }
            return new InformeImportacion(leidas, aceptadas, leidas - aceptadas, motivos);
        }
        // Cierre INVERSO: primero el lector, luego la sesion (que consolida
        // sus estadisticas y libera el bloqueo del catalogo).
    }

    /** Crea un fichero de ejemplo si no existe. Otro try-with-resources. */
    public static void crearFicheroDeEjemplo(String ruta) throws IOException {
        File fichero = new File(ruta);
        if (fichero.exists()) {
            return;
        }
        try (BufferedWriter escritor = new BufferedWriter(new FileWriter(ruta))) {
            escritor.write("# Catalogo de ejemplo de BiblioTech");   escritor.newLine();
            escritor.write("# referencia;titulo;autor;anio;isbn");   escritor.newLine();
            escritor.write("LIB-0001;Java Efectivo;Bloch;2018;978-0000000001");    escritor.newLine();
            escritor.write("LIB-0002;Patrones de Diseno;GoF;1994;978-0000000002"); escritor.newLine();
            escritor.write("LIB-0003;Refactorizacion;Fowler;1999;978-0000000003"); escritor.newLine();
            escritor.write("LIB-0004;Sin autor");                                  escritor.newLine();
            escritor.write("LIB-0005;Mal anio;Autor;mil;978-0000000005");          escritor.newLine();
            escritor.write("LIB-0001;Duplicado;Otro;2020;978-0000000006");         escritor.newLine();
            escritor.write("LIB-0007;Anio absurdo;Autor;1200;978-0000000007");     escritor.newLine();
        }
        System.out.println("  (fichero de ejemplo creado en " + ruta + ")");
    }

    // ------------------------------------------------------------------

    public static void main(String[] args) {
        String ruta = "catalogo-entrada.txt";

        Catalogo catalogo = new Catalogo();
        ImportadorCatalogo importador = new ImportadorCatalogo(catalogo);

        System.out.println("=== 1. Preparacion ===");
        try {
            crearFicheroDeEjemplo(ruta);
        } catch (IOException e) {
            System.out.println("  No se pudo crear el fichero de ejemplo: " + e.getMessage());
            return;
        }

        System.out.println("\n=== 2. Importacion normal ===");
        try {
            InformeImportacion informe = importador.importar(ruta);
            System.out.print(informe.resumen());
            System.out.println("Catalogo: " + catalogo.tamano() + " materiales");
        } catch (IOException e) {
            System.out.println("  Fallo de E/S: " + e.getMessage());
        }

        System.out.println("\n=== 3. Fichero inexistente ===");
        try {
            importador.importar("no-existe.txt");
        } catch (java.io.FileNotFoundException e) {
            // Subclase de IOException: se puede capturar por separado
            System.out.println("  El fichero no existe. Se continua con el catalogo actual.");
            System.out.println("  Detalle: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("  Otro fallo de E/S: " + e.getMessage());
        }

        System.out.println("\n=== 4. Importacion dentro de una sesion (dos recursos) ===");
        Catalogo otro = new Catalogo();
        ImportadorCatalogo conSesion = new ImportadorCatalogo(otro);
        try {
            InformeImportacion informe = conSesion.importarConSesion(ruta, "EMP-001", 20);
            System.out.print(informe.resumen());
        } catch (IOException e) {
            System.out.println("  Fallo: " + e.getMessage());
        }

        System.out.println("\n=== Estado final ===");
        System.out.println("  Catalogo principal: " + catalogo.tamano() + " materiales");
        System.out.println("  Turnos completados: " + SesionBiblioteca.getTurnosCompletados());
    }
}

=== 1. Preparacion ===
  (fichero de ejemplo creado en catalogo-entrada.txt)

=== 2. Importacion normal ===
=== INFORME DE IMPORTACION ===
Lineas leidas : 10
Aceptadas     : 3
Rechazadas    : 7
  * Linea 6: faltan campos -> 'LIB-0004;Sin autor'
  * Linea 7: anio no numerico -> For input string: "mil"
  * Linea 8: REFERENCIA duplicado LIB-0001, ya la usa 'Java Efectivo'
  * Linea 9: dato invalido -> El anio de publicacion debe estar entre 1450 y 2100, y era: 1200
Catalogo: 3 materiales

=== 3. Fichero inexistente ===
  El fichero no existe. Se continua con el catalogo actual.
  Detalle: no-existe.txt (No such file or directory)

=== 4. Importacion dentro de una sesion (dos recursos) ===
  [sesion de EMP-001 abierta el dia 20]
  [sesion de EMP-001 cerrada] 3 prestamos, 0 devoluciones, 0,00 EUR
=== INFORME DE IMPORTACION ===
Lineas leidas : 10
Aceptadas     : 3
Rechazadas    : 7
...

=== Estado final ===
  Catalogo principal: 3 materiales
  Turnos completados: 1