Revision de calidad: DAAS26-P-A

.github/workflows/Java17CImaven.yml

@@ -19,6 +19,9 @@ jobs:
 
     runs-on: ubuntu-latest
 
+    permissions:
+      contents: write
+
     steps:
     - uses: actions/checkout@v4
     - name: Set up JDK 17

.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,4 @@
+eclipse.preferences.version=1
+encoding//src/main/java=UTF-8
+encoding//src/test/java=UTF-8
+encoding/<project>=UTF-8

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,8 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
+org.eclipse.jdt.core.compiler.release=disabled
+org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

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

@@ -1,63 +1,93 @@
-/**
- * 
- */
 package ubu.gii.dass.c01;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Disabled;
-
+import org.junit.jupiter.api.Test;
 
+class ReusablePoolTest {
 
-/**
- * @author alumno
- *
- */
-public class ReusablePoolTest {
+    @Test
+    @DisplayName("testGetInstance")
+    void testGetInstance() {
+		// Comprobacion de que el pool no es nulo y que se comporta como un singleton
+        ReusablePool pool1 = ReusablePool.getInstance();
+        assertNotNull(pool1, "El pool no debería ser nulo tras la inicialización");
+
+		// Comprobamos que dos llamadas a getInstance devuelven la misma instancia
+        ReusablePool pool2 = ReusablePool.getInstance();
+        assertSame(pool1, pool2, "getInstance debe devolver exactamente la misma instancia (Singleton)");
+    }
 
+	@Test
+    @DisplayName("testAcquireReusableSuccess")
+    void testAcquireReusableSuccess() throws Exception {
+        // Modificacion del pool para comprobar que se obtienen objetos reutilizables validos
+        ReusablePool pool = ReusablePool.getInstance();
+        Reusable r = pool.acquireReusable();
+
+        try {
+            assertNotNull(r, "Debe devolver un objeto Reusable valido");
+        } finally {
+            // Restauramos el pool a su estado original para los demas tests
+            pool.releaseReusable(r);
+        }
+    }
 
-	@BeforeAll
-	public static void setUp(){
-	}
-
+	@Test
+    @DisplayName("testAcquireReusableThrowsException")
+    void testAcquireReusableThrowsException() throws Exception {
+        // Modificacion del pool para dejarlo sin instancias libres y comprobar que lanza la excepcion
+        ReusablePool pool = ReusablePool.getInstance();
+
+        // Vaciamos el pool (asumiendo que tiene tamaño 2)
+        Reusable r1 = pool.acquireReusable();
+        Reusable r2 = pool.acquireReusable();
+
+        try {
+            // El tercer intento debe lanzar la excepcion
+            assertThrows(NotFreeInstanceException.class, () -> {
+                pool.acquireReusable();
+            }, "Debe lanzar NotFreeInstanceException al no haber instancias libres");
+        } finally {
+            // Restauramos el pool a su estado original para los demas tests
+            pool.releaseReusable(r1);
+            pool.releaseReusable(r2);
+        }
+    }
 
-	@AfterAll
-	public static void tearDown() throws Exception {
-	}
-
-	/**
-	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#getInstance()}.
-	 */
-        @Test
-        @DisplayName("testGetInstance")
-        @Disabled("Not implemented yet")
-	public void testGetInstance() {
-
-	}
-
-	/**
-	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}.
-	 */
 	@Test
-        @DisplayName("testAcquireReusable")
-        @Disabled("Not implemented yet")
-
-	public void testAcquireReusable() {
-
-	}
-
-	/**
-	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#releaseReusable(ubu.gii.dass.c01.Reusable)}.
-	 */
+    @DisplayName("testReleaseReusableSuccess")
+    void testReleaseReusableSuccess() throws Exception {
+        // Modificacion del pool para comprobar que se pueden liberar objetos correctamente sin lanzar excepciones
+        ReusablePool pool = ReusablePool.getInstance();
+
+        // Extraemos uno para vaciar un hueco
+        Reusable r = pool.acquireReusable();
+
+        // Restauramos el pool a su estado original para los demas tests
+        assertDoesNotThrow(() -> {
+            pool.releaseReusable(r);
+        }, "No debe lanzar excepcion al liberar una instancia valida que no esta en el pool");
+    }
+
 	@Test
-        @DisplayName("testReleaseReusable")
-        @Disabled("Not implemented yet")
-	public void testReleaseReusable() {
+    @DisplayName("testReleaseReusableThrowsException")
+    void testReleaseReusableThrowsException() throws Exception {
+        // Modificacion del pool para comprobar que al intentar liberar un objeto que ya esta en el pool se lanza la excepcion
+        ReusablePool pool = ReusablePool.getInstance();
+
+        // Sacamos una instancia
+        Reusable r = pool.acquireReusable();
+
+        assertThrows(DuplicatedInstanceException.class, () -> {
+            pool.releaseReusable(r); // Primera devolucion funciona y deja el pool restaurado
+            pool.releaseReusable(r); // Segunda devolucion lanza excepcion
+        }, "Debe lanzar DuplicatedInstanceException al intentar devolver un objeto que ya esta en el pool");
 
-	}
-
-}
+    }
+	
+}