From 60e195fd0395b33e4dd8a96c77b1b42df6be2c1a Mon Sep 17 00:00:00 2001 From: knzrd Date: Tue, 27 May 2025 13:53:04 +0200 Subject: [PATCH] Tests 3 cas de scenarios --- .../graphs/algorithm/utils/TestDijkstra.java | 199 ++++++++++++++++-- 1 file changed, 180 insertions(+), 19 deletions(-) diff --git a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/TestDijkstra.java b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/TestDijkstra.java index 3564781..1f36781 100644 --- a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/TestDijkstra.java +++ b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/TestDijkstra.java @@ -5,6 +5,7 @@ import java.io.DataInputStream; import java.io.FileInputStream; import java.util.List; +import org.insa.graphs.algorithm.AbstractSolution; import org.insa.graphs.algorithm.ArcInspector; import org.insa.graphs.algorithm.ArcInspectorFactory; import org.insa.graphs.algorithm.shortestpath.BellmanFordAlgorithm; @@ -109,10 +110,50 @@ final String mapName8= "/mnt/commetud/3eme Annee MIC/Graphes-et-Algorithmes/Maps // Vérifier la validité du chemin : utilisation de .isvalid() // fonction qui extrait le chemin valide +public static boolean SolutionInfaisableDijkstra (ShortestPathData Data){ + DijkstraAlgorithm Dijkstra = new DijkstraAlgorithm(Data); + ShortestPathSolution SolutionDijkstra = Dijkstra.run(); + if (SolutionDijkstra.getStatus()!=AbstractSolution.Status.INFEASIBLE){ + return false; + } + return true; +} +public static boolean SolutionInfaisableBellmanFord (ShortestPathData Data){ + BellmanFordAlgorithm BellmanFord = new BellmanFordAlgorithm(Data); + ShortestPathSolution SolutionBellmanFord= BellmanFord.run(); + if (SolutionBellmanFord.getStatus()!=AbstractSolution.Status.INFEASIBLE){ + return false; + } + return true; +} public static boolean boncheminDijkstra (ShortestPathData Data,Path chemindepart){ // on regarde d'abord si les chemins sont valides + Path chemintrouve = Path_Dijkstra(Data); + // Cas 1 : aucun chemin n'existe +if (chemintrouve == null && chemindepart == null) { + System.out.println("Aucun chemin trouvé (null)."); + return true; // les deux algos ont échoué à trouver un chemin, cohérent +} +if (chemintrouve == null || chemindepart == null) { + System.out.println("Un seul chemin est null, l'autre non."); + return false; // incohérence entre les deux +} + +// Cas 2 : chemin vide (origine = destination, coût nul) +if (chemintrouve.isEmpty() && chemindepart.isEmpty()) { + System.out.println("Chemins vides mais valides (origine = destination)."); + return true; +} +if (chemintrouve.isEmpty() || chemindepart.isEmpty()) { + System.out.println("Un seul chemin vide, l'autre non."); + return false; +} + if(!(chemintrouve.isEmpty()) && chemindepart.isEmpty() ){ + System.out.println(" chemin vide"); + return true; + } if(!(chemintrouve.isValid()) || !(chemindepart.isValid()) ){ System.out.println(" chemin(s) non valide"); return false; @@ -195,7 +236,7 @@ public static boolean memetemps (ShortestPathData Data){ System.out.println("Dijkstra et BellmanFord ont des temps différents de parcours"); return false; } - System.out.println("Dijkstra et BellmanFord ont les même temps de parcours"); + System.out.println("Dijkstra et BellmanFord ont les même temps de parcours"+CostDijkstra); return true; } // Vérifier que le coût en distance est similaire entre Dijkstra et Bellman-Ford @@ -222,11 +263,10 @@ public static boolean memedistance (ShortestPathData Data){ System.out.println("Dijkstra et BellmanFord ont des distances différentes de parcours"); return false; } - System.out.println("Dijkstra et BellmanFord ont les même distances de parcours"); + System.out.println("Dijkstra et BellmanFord ont les même distances de parcours" + CostDijkstra); return true; } - -public static boolean memepath (ShortestPathData Data){ +public static boolean memepathtemps (ShortestPathData Data){ // Recuperation Path de Dijkstra Path PathDijkstra =Path_Dijkstra(Data); // Recuperation Path de BellmanFord @@ -260,6 +300,53 @@ public static boolean memepath (ShortestPathData Data){ // Recuperation du cout des arcs Double tempsArcDijkstra = ArcsDijkstra.get(i).getMinimumTravelTime(); Double tempsArcBellmanFord = ArcsBellmanFord.get(i).getMinimumTravelTime(); + + if(OrigineDijkstra.getId()!= OrigineBellmanFord.getId()|| DestinationDijkstra.getId()!= DestinationBellmanFord.getId() ){ + System.out.println("A partir de l'arc"+i+"les paths ne sont pas les mêmes"); + return false; + } + final double EPSILON = 1e-3; + if(Math.abs(tempsArcDijkstra - tempsArcBellmanFord )> EPSILON){ + System.out.println("A partir de l'arc"+i+"les paths n'ont plus la meme taille"); + return false; + } + } + + System.out.println("Dijkstra et BellmanFord ont les même paths"); + return true; +} +public static boolean memepathdistance (ShortestPathData Data){ + // Recuperation Path de Dijkstra + Path PathDijkstra =Path_Dijkstra(Data); + // Recuperation Path de BellmanFord + Path PathBellmanFord =Path_BellmanFord(Data); + + // Verifier si un path existe avant de verifier sa validite pour eviter probs de pointeur + if (!ExistancePaths(PathDijkstra, PathBellmanFord)){ + return false; + } + + // Verification de la validité des Path + if(!ValiditePaths(PathDijkstra, PathBellmanFord)){ + return false; + } + + // verification de la similarite des paths + // comparer l'ensemble des origines et destination des arcs et leurs couts + List ArcsDijkstra = PathDijkstra.getArcs(); + List ArcsBellmanFord = PathBellmanFord.getArcs(); + // Verifier si on a la meme taille d'arc + if(ArcsDijkstra.size() != ArcsBellmanFord.size()){ + return false; + } + // Verifier que les arcs ont même origine et même destination + for (int i=0;i