diff --git a/README.md b/README.md index c303acf..2a83cde 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ Dans sa version initiale, le programme fournit est un simple code qui se lance e Une fois le programme compilé, vous trouverez un jar executable dans le dossier target. Au nom de jar près (version changeante), vous pourrez l'exécuter avec: ``` -java -jar project-2024.1.0.0-SNAPSHOT.jar --info +java -jar target/project-2024.1.0.0-SNAPSHOT.jar --info ``` L'option de lancement `--info` causera l'affichage dans la console d'informations de l'application. diff --git a/src/test/java/fr/u_paris/gla/project/idfm/CSVStreamProviderTest.java b/src/test/java/fr/u_paris/gla/project/idfm/CSVStreamProviderTest.java new file mode 100644 index 0000000..2c7c7fa --- /dev/null +++ b/src/test/java/fr/u_paris/gla/project/idfm/CSVStreamProviderTest.java @@ -0,0 +1,122 @@ +package fr.u_paris.gla.project.idfm; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import java.lang.reflect.Method; +import java.text.MessageFormat; +import java.text.NumberFormat; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import org.junit.jupiter.api.Test; +import fr.u_paris.gla.project.io.NetworkFormat; +import fr.u_paris.gla.project.utils.GPS; + +public class CSVStreamProviderTest { + + //Test de hasNext, pour le cas ou il y'a un trace et cas ou il n'y en a pas + @Test + public void testHasNext() { + // Scénario sans Trace + CSVStreamProvider providerWithoutTrace = new CSVStreamProvider(Collections.emptyIterator()); + assertFalse(providerWithoutTrace.hasNext(), "hasNext should return false when no traces are provided"); + + // Scénario avec Trace + StopEntry stop1 = new StopEntry("Stop1", 2.3522, 48.8566); + StopEntry stop2 = new StopEntry("Stop2", 2.295, 48.8738); + List path = Arrays.asList(stop1, stop2); + + TraceEntry trace = new TraceEntry("Ligne1"); + trace.addPath(path); + + CSVStreamProvider providerWithTrace = new CSVStreamProvider(Arrays.asList(trace).iterator()); + assertTrue(providerWithTrace.hasNext(), "hasNext should return true when traces are provided"); + } + + + + //Test de la methode next() + @Test + public void testNext() { + // Initialisation des données d'exemple directement dans le test + StopEntry start = new StopEntry("Début", 2.3522, 48.8566); // Paris + StopEntry end = new StopEntry("Fin", 2.295, 48.8738); // Proche de Paris + + TraceEntry traceEntry = new TraceEntry("Ligne1"); + traceEntry.addPath(Arrays.asList(start, end)); // Ajout d'un chemin à la trace + + CSVStreamProvider provider = new CSVStreamProvider(Collections.singletonList(traceEntry).iterator()); + + assertTrue(provider.hasNext(), "Doit avoir un prochain élément"); + + String[] result = provider.next(); + assertNotNull(result, "Le résultat ne doit pas être null"); + + // Vérifications spécifiques sur le format des données de sortie + assertEquals(start.lname, result[NetworkFormat.START_INDEX], "Le nom de l'arrêt de départ doit correspondre"); + assertEquals(end.lname, result[NetworkFormat.STOP_INDEX], "Le nom de l'arrêt d'arrivée doit correspondre"); + + // Calcul et vérification de la distance attendue + double expectedDistance = GPS.distance(start.latitude, start.longitude, end.latitude, end.longitude); + String expectedDistanceFormatted = NumberFormat.getInstance(Locale.ENGLISH).format(expectedDistance); + assertEquals(expectedDistanceFormatted, result[NetworkFormat.DISTANCE_INDEX], "La distance doit correspondre"); + } + + + + //Test de la methode private fillStation avec la réflexion + @Test + public void testFillStation() throws Exception { + // Initialisation des données de test + StopEntry stop = new StopEntry("StopName", 2.3522, 48.8566); // Exemple de coordonnées pour Paris + String[] nextLine = new String[NetworkFormat.NUMBER_COLUMNS]; + + // Accès à la méthode fillStation via la réflexion + Method fillStationMethod = CSVStreamProvider.class.getDeclaredMethod("fillStation", StopEntry.class, String[].class, int.class); + fillStationMethod.setAccessible(true); + + // Invocation de la méthode fillStation + fillStationMethod.invoke(null, stop, nextLine, NetworkFormat.START_INDEX); + + // Format attendu pour la latitude et la longitude + NumberFormat gpsFormatter = NetworkFormat.getGPSFormatter(); + String expectedLatitudeLongitude = MessageFormat.format("{0}, {1}", + gpsFormatter.format(stop.latitude), + gpsFormatter.format(stop.longitude)); + + // Vérifications + assertEquals(stop.lname, nextLine[NetworkFormat.START_INDEX], "Le nom de l'arrêt doit correspondre."); + assertEquals(expectedLatitudeLongitude, nextLine[NetworkFormat.START_INDEX + 1], "Les coordonnées GPS doivent correspondre."); + } + + + + + //Test de la méthode static private distanceToTime() + @Test + public void testDistanceToTime() throws Exception { + // Valeurs fictives pour TWO_ACCELERATION_DISTANCE et MAX_SPEED + final double TWO_ACCELERATION_DISTANCE = 0.2; // Par exemple + final double MAX_SPEED = 5.0; // Par exemple + + // Exemple de distance à tester + double distanceExample = 1.0; // 1 km + + // Calcul attendu basé sur la formule fournie + double expected = Math.max(0, distanceExample - TWO_ACCELERATION_DISTANCE) / MAX_SPEED + + Math.pow(Math.min(distanceExample, TWO_ACCELERATION_DISTANCE) / MAX_SPEED, 2); + + // Accès à la méthode distanceToTime via la réflexion + Method method = CSVStreamProvider.class.getDeclaredMethod("distanceToTime", double.class); + method.setAccessible(true); + + // Invocation de la méthode distanceToTime et stockage du résultat + double result = (Double) method.invoke(null, distanceExample); + + // Assertion pour vérifier si le résultat est conforme à l'attendu + assertEquals(expected, result, "Le calcul du temps à partir de la distance devrait être conforme à l'attendu."); + } +} \ No newline at end of file diff --git a/src/test/java/fr/u_paris/gla/project/idfm/IDFMNetworkExtractorTest.java b/src/test/java/fr/u_paris/gla/project/idfm/IDFMNetworkExtractorTest.java new file mode 100644 index 0000000..35c1d3e --- /dev/null +++ b/src/test/java/fr/u_paris/gla/project/idfm/IDFMNetworkExtractorTest.java @@ -0,0 +1,59 @@ +package fr.u_paris.gla.project.idfm; +import org.junit.jupiter.api.Test; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; + + +class IDFMNetworkExtractorTest { + + //Test de clenLine de ma classe IDFMNetworkExtractor + @Test + public void testCleanLine() throws Exception { + // Création d'un arrêt non identifié avec des coordonnées spécifiques + UnidentifiedStopEntry unidentifiedStop = new UnidentifiedStopEntry(2.3522, 48.8566); // Coordonnées pour Paris + + // Création d'un arrêt candidat proche de l'arrêt non identifié + StopEntry closeCandidate = new StopEntry("Proche Candidat", 2.3523, 48.8567); // Coordonnées proches de Paris + + // Ajout du candidat à l'arrêt non identifié + unidentifiedStop.addCandidate(closeCandidate); + + // Liste des chemins contenant l'arrêt non identifié + List> paths = new ArrayList<>(Arrays.asList(Arrays.asList(unidentifiedStop))); + + // Accès à la méthode cleanLine via la réflexion + Method cleanLineMethod = IDFMNetworkExtractor.class.getDeclaredMethod("cleanLine", List.class); + cleanLineMethod.setAccessible(true); + + // Invocation de la méthode cleanLine + boolean result = (Boolean) cleanLineMethod.invoke(null, paths); + + // Vérifications + assertTrue(result, "La méthode cleanLine devrait retourner true si le nettoyage a réussi."); + assertNotEquals("Unidentified", paths.get(0).get(0).lname, "L'arrêt non identifié devrait avoir été résolu."); + assertEquals(closeCandidate.lname, paths.get(0).get(0).lname, "L'arrêt devrait être résolu au candidat le plus proche."); + } + + + + @Test + public void testAddCandidate() throws Exception { + UnidentifiedStopEntry unidentifiedStop = new UnidentifiedStopEntry(2.3522, 48.8566); // Coordonnées pour Paris + List path = new ArrayList<>(Arrays.asList(unidentifiedStop)); + TraceEntry trace = new TraceEntry("Ligne1"); + trace.addPath(path); + + StopEntry candidate = new StopEntry("Proche Candidat", 2.3523, 48.8567); // Coordonnées proches + + Method method = IDFMNetworkExtractor.class.getDeclaredMethod("addCandidate", TraceEntry.class, StopEntry.class); + method.setAccessible(true); + + method.invoke(null, trace, candidate); + + //L'appel c'est derouler correctement + assertTrue(true, "L'appel de addCandidate s'est déroulé sans erreur."); + } +} \ No newline at end of file diff --git a/src/test/java/fr/u_paris/gla/project/idfm/StopEntryTest.java b/src/test/java/fr/u_paris/gla/project/idfm/StopEntryTest.java index 85213cf..a40659d 100644 --- a/src/test/java/fr/u_paris/gla/project/idfm/StopEntryTest.java +++ b/src/test/java/fr/u_paris/gla/project/idfm/StopEntryTest.java @@ -11,8 +11,8 @@ public class StopEntryTest { // Mise à jour de la valeur attendue pour correspondre au formatage réel String expected = "Chatelet [2.347, 48.853]"; assertEquals(expected, stop.toString()); - } - + } + //Test de compareTo @Test public void testCompareTo() { diff --git a/src/test/java/fr/u_paris/gla/project/idfm/TraceEntryTest.java b/src/test/java/fr/u_paris/gla/project/idfm/TraceEntryTest.java index 0a76904..6ba7bdb 100644 --- a/src/test/java/fr/u_paris/gla/project/idfm/TraceEntryTest.java +++ b/src/test/java/fr/u_paris/gla/project/idfm/TraceEntryTest.java @@ -1,7 +1,6 @@ package fr.u_paris.gla.project.idfm; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; - import java.util.Arrays; import java.util.List; diff --git a/src/test/java/fr/u_paris/gla/project/idfm/UnidentifiedStopEntryTest.java b/src/test/java/fr/u_paris/gla/project/idfm/UnidentifiedStopEntryTest.java new file mode 100644 index 0000000..a4ac1c7 --- /dev/null +++ b/src/test/java/fr/u_paris/gla/project/idfm/UnidentifiedStopEntryTest.java @@ -0,0 +1,84 @@ +package fr.u_paris.gla.project.idfm; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Test; + + +public class UnidentifiedStopEntryTest { + + + // Test de la méthode resolve de la classe UnidentifiedStopEntry + @Test + public void testResolve() { + // Création d'un UnidentifiedStopEntry avec des coordonnées arbitraires (0,0) + UnidentifiedStopEntry unidentifiedStopEntry = new UnidentifiedStopEntry(0, 0); + + // Test lorsque la liste des candidats est vide + assertNull(unidentifiedStopEntry.resolve()); + + // Test lorsque la liste des candidats contient un seul StopEntry + StopEntry stopEntry1 = new StopEntry("Stop1", 10.0, 20.0); + unidentifiedStopEntry.addCandidate(stopEntry1); + assertEquals(stopEntry1, unidentifiedStopEntry.resolve()); + + // Test lorsque la liste des candidats contient plusieurs StopEntries + StopEntry stopEntry2 = new StopEntry("Stop2", 30.0, 40.0); + unidentifiedStopEntry.addCandidate(stopEntry2); + // En supposant que la méthode GPS.distance fonctionne correctement, stopEntry1 devrait être plus proche + assertEquals(stopEntry1, unidentifiedStopEntry.resolve()); + + // Test lorsque la liste des candidats contient plusieurs StopEntries et que le plus proche change + UnidentifiedStopEntry unidentifiedStopEntry2 = new UnidentifiedStopEntry(35.0, 45.0); + unidentifiedStopEntry2.addCandidate(stopEntry1); + unidentifiedStopEntry2.addCandidate(stopEntry2); + // Maintenant, stopEntry1 devrait être plus proche + assertEquals(stopEntry1, unidentifiedStopEntry2.resolve()); + } + + + // Test de la méthode addCandidate de la classe UnidentifiedStopEntry + @Test + public void testAddCandidate() { + // Création d'un UnidentifiedStopEntry avec des coordonnées arbitraires (0,0) + UnidentifiedStopEntry unidentifiedStopEntry = new UnidentifiedStopEntry(0, 0); + + // Test lorsque nous ajoutons un StopEntry à la liste des candidats + StopEntry stopEntry1 = new StopEntry("Stop1", 10.0, 20.0); + unidentifiedStopEntry.addCandidate(stopEntry1); + assertEquals(stopEntry1, unidentifiedStopEntry.resolve()); + + // Test lorsque nous ajoutons un autre StopEntry à la liste des candidats + StopEntry stopEntry2 = new StopEntry("Stop2", 30.0, 40.0); + unidentifiedStopEntry.addCandidate(stopEntry2); + // En supposant que la méthode GPS.distance fonctionne correctement, stopEntry1 devrait être plus proche + assertEquals(stopEntry1, unidentifiedStopEntry.resolve()); + } + + + // Test de la méthode equals de la classe UnidentifiedStopEntry + @Test + public void testEquals() { + // Création de deux UnidentifiedStopEntry avec les mêmes coordonnées + UnidentifiedStopEntry unidentifiedStopEntry1 = new UnidentifiedStopEntry(0, 0); + UnidentifiedStopEntry unidentifiedStopEntry2 = new UnidentifiedStopEntry(0, 0); + + // Test lorsque nous comparons un UnidentifiedStopEntry avec lui-même + assertTrue(unidentifiedStopEntry1.equals(unidentifiedStopEntry1)); + + // Test lorsque nous comparons deux UnidentifiedStopEntry qui n'ont pas de candidats + assertTrue(unidentifiedStopEntry1.equals(unidentifiedStopEntry2)); + + // Test lorsque nous ajoutons le même StopEntry aux deux UnidentifiedStopEntry + StopEntry stopEntry = new StopEntry("Stop1", 10.0, 20.0); + unidentifiedStopEntry1.addCandidate(stopEntry); + unidentifiedStopEntry2.addCandidate(stopEntry); + assertTrue(unidentifiedStopEntry1.equals(unidentifiedStopEntry2)); + + // Test lorsque nous ajoutons un autre StopEntry à l'un des UnidentifiedStopEntry + StopEntry stopEntry2 = new StopEntry("Stop2", 30.0, 40.0); + unidentifiedStopEntry1.addCandidate(stopEntry2); + assertFalse(unidentifiedStopEntry1.equals(unidentifiedStopEntry2)); + } +} \ No newline at end of file