Mejora de los casos de prueba para conseguir mayor cobertura

Author: ibaimoya

src/test/java/ubu/gii/dass/c01/ReusablePoolTest.java

@@ -41,24 +41,24 @@ public static void tearDown() throws Exception {
     }
 
     /**
-     * Test method for {@link ubu.gii.dass.c01.ReusablePool#getInstanceReusable()}.
+     * Método de prueba para {@link ubu.gii.dass.c01.ReusablePool#getInstanceReusable()}.
      */
     @Test
     @DisplayName("testGetInstance")
     public void testGetInstance() {
         try {
             ReusablePool pool1 = ReusablePool.getInstance();
             ReusablePool pool2 = ReusablePool.getInstance();
-            assertNotNull(pool1);
-            assertNotNull(pool2);
-            assertEquals(pool1, pool2, "Ambas son identicas");
+            assertNotNull(pool1, "La instancia pool1 no debería ser nula.");
+            assertNotNull(pool2, "La instancia pool2 no debería ser nula.");
+            assertEquals(pool1, pool2, "Ambos deben ser idénticos");
         } catch (Exception e) {
-            fail("Exception en testGetInstance " + e.getMessage());
+            fail("Excepción en testGetInstance: " + e.getMessage());
         }
     }
 
     /**
-     * Test method for {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}.
+     * Método de prueba para {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}.
      */
     @Test
     @DisplayName("testAcquireReusable")
@@ -67,6 +67,7 @@ public void testAcquireReusable() {
         // Se almacenan los reusables adquiridos para compararlos
         Reusable[] reusables = new Reusable[ReusablePoolTest.maxResources];
 
+        // Adquirir el máximo de instancias disponibles
         for (int numReusable = 0; numReusable < ReusablePoolTest.maxResources; numReusable++) {
             try {
                 reusables[numReusable] = pool.acquireReusable();
@@ -76,24 +77,32 @@ public void testAcquireReusable() {
             }
         }
 
-        // Verifica que los reusables adquiridos sean distintos entre sí
+        // Verificar que los reusables adquiridos sean distintos entre sí
         for (int i = 0; i < ReusablePoolTest.maxResources - 1; i++) {
             for (int j = i + 1; j < ReusablePoolTest.maxResources; j++) {
                 assertNotEquals(reusables[i], reusables[j], "Los reusables deben ser distintos.");
             }
         }
 
         // Comprueba que una nueva adquisición lanza una excepción
-        try {
+        assertThrows(NotFreeInstanceException.class, () -> {
             pool.acquireReusable();
-            fail("Excepcion NotFreeInstanceException no se ha lanzado al adquirir una nueva instancia reusable");
-        } catch (NotFreeInstanceException ex) {
-            // Se espera una excepción, si llega hasta aquí, el código es correcto.
+        }, "No se lanzó NotFreeInstanceException al intentar adquirir más instancias.");
+
+        // Caso límite adicional: Liberar una instancia y volver a adquirirla
+        try {
+            pool.releaseReusable(reusables[0]);
+            Reusable reciclado = pool.acquireReusable();
+            assertNotNull(reciclado, "El reusable reciclado es nulo.");
+            assertSame(reusables[0], reciclado, "El recurso debe ser reutilizado tras liberarlo");
+            pool.releaseReusable(reciclado);
+        } catch (Exception ex) {
+            fail("Error en el caso límite adicional de testAcquireReusable: " + ex.getMessage());
         }
     }
 
     /**
-     * Test method for {@link ubu.gii.dass.c01.ReusablePool#releaseReusable()}.
+     * Método de prueba para {@link ubu.gii.dass.c01.ReusablePool#releaseReusable()}.
      */
     @Test
     @DisplayName("testReleaseReusable")
@@ -102,19 +111,32 @@ public void testReleaseReusable() {
             ReusablePool pool = ReusablePool.getInstance();
             Reusable obj1 = pool.acquireReusable();
 
-            assertNotNull(obj1, "No deberia ser null");
+            assertNotNull(obj1, "El reusable no debería ser nulo.");
             pool.releaseReusable(obj1);
 
             Reusable obj2 = pool.acquireReusable();
-            assertSame(obj1, obj2, "Tiene que ser reusado");
+            assertSame(obj1, obj2, "El reusable debe ser reutilizado.");
             pool.releaseReusable(obj2);
 
-            // Try to release the same object again to trigger DuplicatedInstanceException
+            // Caso límite: Intentar liberar null debe lanzar excepción
+            assertThrows(IllegalArgumentException.class, () -> {
+                pool.releaseReusable(null);
+            }, "No se lanzó IllegalArgumentException al intentar liberar null.");
+
+            // Caso límite: Liberar un objeto no gestionado por el pool
+            // Suponemos que crear un objeto Reusable directamente no está permitido
+            Reusable fakeReusable = new Reusable();
+            assertThrows(IllegalArgumentException.class, () -> {
+                pool.releaseReusable(fakeReusable);
+            }, "No se lanzó IllegalArgumentException al intentar liberar un objeto no adquirido previamente.");
+
+            // Caso límite adicional: Intentar liberar nuevamente el mismo objeto
+            pool.releaseReusable(obj2);
             assertThrows(DuplicatedInstanceException.class, () -> {
                 pool.releaseReusable(obj2);
-            });
+            }, "No se lanzó DuplicatedInstanceException al intentar liberar dos veces el mismo objeto.");
         } catch (Exception e) {
-            fail("Excepcion en testReleaseReusable: " + e.getMessage());
+            fail("Excepción en testReleaseReusable: " + e.getMessage());
         }
     }
 }