From 6afbebb54877637af6c658dcaacd639f3e208620 Mon Sep 17 00:00:00 2001
From: knzrd <zridkenza@gmail.com>
Date: Tue, 27 May 2025 21:59:17 +0200
Subject: [PATCH] Test Astar

---
 .../graphs/algorithm/utils/TestAstar.java     | 212 +++++++++---------
 1 file changed, 112 insertions(+), 100 deletions(-)

diff --git a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/TestAstar.java b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/TestAstar.java
index d9e8b0f..9dc40d6 100644
--- a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/TestAstar.java
+++ b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/TestAstar.java
@@ -10,7 +10,6 @@ import org.insa.graphs.algorithm.AbstractSolution;
 import org.insa.graphs.algorithm.ArcInspector;
 import org.insa.graphs.algorithm.ArcInspectorFactory;
 import org.insa.graphs.algorithm.shortestpath.AStarAlgorithm;
-import org.insa.graphs.algorithm.shortestpath.BellmanFordAlgorithm;
 import org.insa.graphs.algorithm.shortestpath.DijkstraAlgorithm;
 import org.insa.graphs.algorithm.shortestpath.ShortestPathData;
 import org.insa.graphs.algorithm.shortestpath.ShortestPathSolution;
@@ -88,10 +87,10 @@ public static boolean SolutionInfaisableDijkstra (ShortestPathData Data){
     return true;
 }
 // comparer les paths auxquelles on nous a donne acces et les comparer au Dijkstra obtenu
-public static boolean boncheminDijkstra (ShortestPathData Data,Path chemindepart){
+public static boolean boncheminAstar (ShortestPathData Data,Path chemindepart){
     // on regarde d'abord si les chemins sont valides
     
-    Path chemintrouve = Path_Dijkstra(Data);
+    Path chemintrouve = Path_Astar(Data);
     // Cas 1 : aucun chemin n'existe
 if (chemintrouve == null && chemindepart == null) {
     System.out.println("Aucun chemin trouvé (null).");
@@ -147,11 +146,11 @@ public static Path Path_Dijkstra(ShortestPathData Data){
 } 
 
 // Recuperation Path de BellmanFord pour petites cartes uniquement
-public static Path Path_BellmanFord(ShortestPathData Data){
+public static Path Path_Astar(ShortestPathData Data){
 
-    BellmanFordAlgorithm BellmanFord = new BellmanFordAlgorithm(Data);
-    ShortestPathSolution SolutionBellmanFord = BellmanFord.run();
-    return SolutionBellmanFord.getPath();
+    AStarAlgorithm Astar = new AStarAlgorithm(Data);
+    ShortestPathSolution SolutionAstar = Astar.run();
+    return SolutionAstar.getPath();
 } 
 // Verification existance de deux Paths
 public static boolean ExistancePaths(Path PathDijkstra,Path PathBellmanFord){
@@ -170,29 +169,35 @@ if(!(PathDijkstra.isValid())|| !(PathBellmanFord.isValid()) ){
    } 
 else{ return true;} 
 } 
-    // Vérifier que le coût en temps est similaire entre Dijkstra et Bellman-Ford
+    // Vérifier que le coût en temps de Astar est egale 
 public static boolean memetemps  (ShortestPathData Data){
     // Recuperation Path de Dijkstra
     Path PathDijkstra =Path_Dijkstra(Data);
     // Recuperation Path de BellmanFord
-    Path PathBellmanFord =Path_BellmanFord(Data);
+    Path PathAstar =Path_Astar(Data);
     // Verifier si un path existe avant de verifier sa validite pour eviter probs de pointeur
-    if (!ExistancePaths(PathDijkstra, PathBellmanFord)){
+    if (!ExistancePaths(PathDijkstra, PathAstar)){
         return false;
     } 
    // Verification de la validité des Path
-   if(!ValiditePaths(PathDijkstra, PathBellmanFord)){
+   if(!ValiditePaths(PathDijkstra, PathAstar)){
     return false;
    } 
 
    // verification du cout en temps
    double CostDijkstra = PathDijkstra.getMinimumTravelTime();
-   double CostBellmanFord = PathBellmanFord.getMinimumTravelTime();
-   if(CostDijkstra != CostBellmanFord){
-    System.out.println("Dijkstra et BellmanFord ont des temps différents de parcours");
+   double CostAstar = PathAstar.getMinimumTravelTime();
+   if(CostDijkstra != CostAstar){
+    if(CostDijkstra>CostAstar){
+        System.out.println("Dijkstra et Astar ont des temps différents de parcours");
     return false;
+    } 
+    else{
+        System.out.println("C'est normal Astar peut prendre plus de temps que Dijkstra");
+        return true;
+    } 
    } 
-   System.out.println("Dijkstra et BellmanFord ont les même temps de parcours"+CostDijkstra);
+   System.out.println("Dijkstra et Astar 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
@@ -200,117 +205,124 @@ public static boolean memedistance  (ShortestPathData Data){
     // Recuperation Path de Dijkstra
     Path PathDijkstra =Path_Dijkstra(Data);
     // Recuperation Path de BellmanFord
-    Path PathBellmanFord =Path_BellmanFord(Data);
+    Path PathAstar =Path_Astar(Data);
 
     // Verifier si un path existe avant de verifier sa validite pour eviter probs de pointeur
-    if (!ExistancePaths(PathDijkstra, PathBellmanFord)){
+    if (!ExistancePaths(PathDijkstra, PathAstar)){
         return false;
     } 
 
    // Verification de la validité des Path
-   if(!ValiditePaths(PathDijkstra, PathBellmanFord)){
+   if(!ValiditePaths(PathDijkstra, PathAstar)){
     return false;
    } 
 
    // verification de la similarite en distance
    double CostDijkstra = PathDijkstra.getLength();
-   double CostBellmanFord = PathBellmanFord.getLength();
-   if(CostDijkstra != CostBellmanFord){
-    System.out.println("Dijkstra et BellmanFord ont des distances différentes de parcours");
+   double CostAstar = PathAstar.getLength();
+   if(CostDijkstra != CostAstar){
+    if (CostDijkstra >CostAstar){
+        System.out.println("Dijkstra et Astar ont des distances différentes de parcours");
     return false;
+    }   
+    else{
+        System.out.println("Astar a une plus longue distance que Dijkstra ce qui est normal");
+        return true;
+    } 
+    
    } 
-   System.out.println("Dijkstra et BellmanFord ont les même distances de parcours" + CostDijkstra);
+   System.out.println("Dijkstra et Astar ont les même distances de parcours" + CostDijkstra);
     return true;
 } 
 public static boolean memepathtemps  (ShortestPathData Data){
     // Recuperation Path de Dijkstra
     Path PathDijkstra =Path_Dijkstra(Data);
     // Recuperation Path de BellmanFord
-    Path PathBellmanFord =Path_BellmanFord(Data);
+    Path PathAstar =Path_Astar(Data);
 
     // Verifier si un path existe avant de verifier sa validite pour eviter probs de pointeur
-    if (!ExistancePaths(PathDijkstra, PathBellmanFord)){
+    if (!ExistancePaths(PathDijkstra, PathAstar)){
         return false;
     } 
 
    // Verification de la validité des Path
-   if(!ValiditePaths(PathDijkstra, PathBellmanFord)){
+   if(!ValiditePaths(PathDijkstra, PathAstar)){
     return false;
    } 
 
    // verification de la similarite des paths
    // comparer l'ensemble des origines et destination des arcs et leurs couts
    List<Arc> ArcsDijkstra  = PathDijkstra.getArcs(); 
-   List<Arc> ArcsBellmanFord = PathBellmanFord.getArcs(); 
+   List<Arc> ArcsAstra = PathAstar.getArcs(); 
    // Verifier si on a la meme taille d'arc
-   if(ArcsDijkstra.size() != ArcsBellmanFord.size()){
+   if(ArcsDijkstra.size() != ArcsAstra.size()){
         return false;
    } 
    // Verifier que les arcs ont même origine et même destination
    for (int i=0;i<ArcsDijkstra.size();i++){
     // Recuperation des Origines et Destinations
     Node OrigineDijkstra = ArcsDijkstra.get(i).getOrigin();
-    Node OrigineBellmanFord = ArcsBellmanFord.get(i).getOrigin();
+    Node OrigineAstar = ArcsAstra.get(i).getOrigin();
     Node DestinationDijkstra = ArcsDijkstra.get(i).getDestination();
-    Node DestinationBellmanFord = ArcsBellmanFord.get(i).getDestination();
+    Node DestinationAstar = ArcsAstra.get(i).getDestination();
     // Recuperation du cout des arcs 
     Double tempsArcDijkstra = ArcsDijkstra.get(i).getMinimumTravelTime();
-    Double tempsArcBellmanFord = ArcsBellmanFord.get(i).getMinimumTravelTime();
+    Double tempsArcAstar = ArcsAstra.get(i).getMinimumTravelTime();
 
-    if(OrigineDijkstra.getId()!= OrigineBellmanFord.getId()|| DestinationDijkstra.getId()!= DestinationBellmanFord.getId()  ){
+    if(OrigineDijkstra.getId()!= OrigineAstar.getId()|| DestinationAstar.getId()!= DestinationDijkstra.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){
+    if(Math.abs(tempsArcDijkstra - tempsArcAstar )> 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");
+   System.out.println("Dijkstra et Astar 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);
+    Path PathAstar =Path_Astar(Data);
 
     // Verifier si un path existe avant de verifier sa validite pour eviter probs de pointeur
-    if (!ExistancePaths(PathDijkstra, PathBellmanFord)){
+    if (!ExistancePaths(PathDijkstra, PathAstar)){
         return false;
     } 
 
    // Verification de la validité des Path
-   if(!ValiditePaths(PathDijkstra, PathBellmanFord)){
+   if(!ValiditePaths(PathDijkstra, PathAstar)){
     return false;
    } 
 
    // verification de la similarite des paths
    // comparer l'ensemble des origines et destination des arcs et leurs couts
    List<Arc> ArcsDijkstra  = PathDijkstra.getArcs(); 
-   List<Arc> ArcsBellmanFord = PathBellmanFord.getArcs(); 
+   List<Arc> ArcsAstar = PathAstar.getArcs(); 
    // Verifier si on a la meme taille d'arc
-   if(ArcsDijkstra.size() != ArcsBellmanFord.size()){
+   if(ArcsDijkstra.size() != ArcsAstar.size()){
         return false;
    } 
    // Verifier que les arcs ont même origine et même destination
    for (int i=0;i<ArcsDijkstra.size();i++){
     // Recuperation des Origines et Destinations
     Node OrigineDijkstra = ArcsDijkstra.get(i).getOrigin();
-    Node OrigineBellmanFord = ArcsBellmanFord.get(i).getOrigin();
+    Node OrigineAstar= ArcsAstar.get(i).getOrigin();
     Node DestinationDijkstra = ArcsDijkstra.get(i).getDestination();
-    Node DestinationBellmanFord = ArcsBellmanFord.get(i).getDestination();
+    Node DestinationAstar = ArcsAstar.get(i).getDestination();
     // Recuperation du cout des arcs 
     float distanceArcDijkstra = ArcsDijkstra.get(i).getLength();
-    float distanceArcBellmanFord = ArcsBellmanFord.get(i).getLength();
+    float distanceArcAstar = ArcsAstar.get(i).getLength();
 
-    if(OrigineDijkstra.getId()!= OrigineBellmanFord.getId()|| DestinationDijkstra.getId()!= DestinationBellmanFord.getId()  ){
+    if(OrigineDijkstra.getId()!= OrigineAstar.getId()|| DestinationDijkstra.getId()!= DestinationAstar.getId()  ){
         System.out.println("A partir de l'arc"+i+"les paths ne sont pas les mêmes");
         return false;
     } 
-    if( distanceArcDijkstra!= distanceArcBellmanFord ){
+    if( distanceArcDijkstra!= distanceArcAstar){
         System.out.println("A partir de l'arc"+i+"les paths n'ont plus la meme taille");
         return false;
     } 
@@ -337,131 +349,131 @@ public static boolean memepathdistance  (ShortestPathData Data){
         // verification du bon chemin
         System.out.println("---------------------------------------------------\n ");
         System.out.println("Test bonchemin\n ");
-        if(boncheminDijkstra(Data1, pathrecupere1)){
-            System.out.println("L'algorithme Dijkstra donne le bon path\n ");
+        if(boncheminAstar(Data1, pathrecupere1)){
+            System.out.println("L'algorithme Astar donne le bon path\n ");
         } 
-        else{System.out.println("L'algorithme Dijkstra ne donne pas le bon path\n");} 
+        else{System.out.println("L'algorithme Astar ne donne pas le bon path\n");} 
         System.out.println("---------------------------------------------------\n ");
-        // Comparaison avec Bellman Ford
+        // Comparaison avec Dijkstra
             // Comparaison de cout en distance
         System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme distance Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme distance Astar et Dijkstra\n ");
         if(memedistance(Data1)){
-            System.out.println("Dijkstra et Bellman Ford donnent le même coût\n ");
+            System.out.println("Dijkstra et Astar donnent le même coût\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas le même\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas le même\n ");} 
     System.out.println("---------------------------------------------------\n ");
 System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme temps Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme temps Bellman-Ford et Astar\n ");
         if(memetemps(Data1)){
-            System.out.println("Dijkstra et Bellman Ford donnent le même temps\n ");
+            System.out.println("Dijkstra et Astar donnent le même temps\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas le même temps\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas le même temps\n ");} 
     System.out.println("---------------------------------------------------\n ");
     // comparaison des paths
     System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme distance Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme distance Bellman-Ford et Astar\n ");
         if(memepathdistance(Data1)){
-            System.out.println("Dijkstra et Bellman Ford ont le meme path\n ");
+            System.out.println("Dijkstra et Astar ont le meme path\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas le même path\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas le même path\n ");} 
     System.out.println("---------------------------------------------------\n ");
     // cas 2 Filter OnlyCarbylength : pas de path
-        // Recuperation du path realise par Dijkstra
+        // Recuperation du path realise par Astar
         ShortestPathData Data2 = new ShortestPathData(graph,pathrecupere1.getOrigin(), pathrecupere1.getDestination(),OnlyCarByLength);
         // verification du fait qu'on n'a pas de chemin
         System.out.println("---------------------------------------------------\n ");
         System.out.println("Test Solution Infaisable\n ");
-        if(SolutionInfaisableDijkstra(Data2)){
-            System.out.println("L'algorithme Dijkstra donne le bon path : infaisable\n ");
+        if(SolutionInfaisableAstar(Data2)){
+            System.out.println("L'algorithme AStar donne le bon path : infaisable\n ");
         } 
-        else{System.out.println("L'algorithme Dijkstra ne donne pas le bon path\n");} 
+        else{System.out.println("L'algorithme AStar ne donne pas le bon path\n");} 
         System.out.println("---------------------------------------------------\n ");
-        // Comparaison avec Bellman Ford : Voir si meme Bellman Ford ne donne rien dans ce cas
+        // Comparaison avec Dijkstra: Voir si meme Dijkstra ne donne rien dans ce cas
         System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme distance Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme distance AStar et Dijkstra\n ");
         if(SolutionInfaisableDijkstra(Data2)){
-            System.out.println("BellmanFord donne un path infaisable \n ");
+            System.out.println("Dijkstra donne un path infaisable \n ");
     }
-    else{System.out.println("BellmanFord donne un path faisable\n ");} 
+    else{System.out.println("Dijkstra donne un path faisable\n ");} 
     System.out.println("---------------------------------------------------\n ");
 
   
     // cas 3 Filter OnlyCarbytime
-        // Recuperation du path realise par Dijkstra
+        // Recuperation du path realise par Astar
         ShortestPathData Data3 = new ShortestPathData(graph,pathrecupere1.getOrigin(), pathrecupere1.getDestination(),OnlyCarByTime);
-        // Comparaison avec Bellman Ford
+        // Comparaison avec Dijkstra
             // Comparaison de cout en distance
         System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme distance Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme distance Astar et Dijkstra\n ");
         if(memedistance(Data3)){
-            System.out.println("Dijkstra et Bellman Ford donnent la meme distance\n ");
+            System.out.println("Dijkstra et Astar donnent la meme distance\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas la meme distance\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas la meme distance\n ");} 
     System.out.println("---------------------------------------------------\n ");
 
       System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme temps Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme temps Astar et Dijkstra\n ");
         if(memetemps(Data3)){
-            System.out.println("Dijkstra et Bellman Ford donnent le même temps\n ");
+            System.out.println("Dijkstra et Astar donnent le même temps\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas le même temps\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas le même temps\n ");} 
     System.out.println("---------------------------------------------------\n ");
 
     // comparaison des paths
     System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme path Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme path Astra et Dijkstra\n ");
         if(memepathdistance(Data3)){
-            System.out.println("Dijkstra et Bellman Ford ont le meme path\n ");
+            System.out.println("Dijkstra et Astar ont le meme path\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas le même path\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas le même path\n ");} 
     System.out.println("---------------------------------------------------\n ");
 
 
     // cas 4 Filter OnlyPedestrianByTime
-        // Recuperation du path realise par Dijkstra
+        // Recuperation du path realise par AStar
         ShortestPathData Data4 = new ShortestPathData(graph,pathrecupere1.getOrigin(), pathrecupere1.getDestination(),OnlyPedestrianByTime);
-        // Comparaison avec Bellman Ford
+        // Comparaison avec Dijkstra
             // Comparaison de cout en distance
         System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme distance Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme distance Astra et Dijkstra\n ");
         if(memedistance(Data4)){
-            System.out.println("Dijkstra et Bellman Ford donnent la meme distance\n ");
+            System.out.println("Dijkstra et Astra donnent la meme distance\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas la meme distance\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas la meme distance\n ");} 
     System.out.println("---------------------------------------------------\n ");
 
       System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme temps Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme temps Astar et Dijkstra\n ");
         if(memetemps(Data4)){
-            System.out.println("Dijkstra et Bellman Ford donnent le même temps\n ");
+            System.out.println("Dijkstra et Astar donnent le même temps\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas le même temps\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas le même temps\n ");} 
     System.out.println("---------------------------------------------------\n ");
 
     // comparaison des paths
     System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test meme path Bellman-Ford et Dijkstra\n ");
+        System.out.println("Test meme path Astar et Dijkstra\n ");
         if(memepathdistance(Data4)){
-            System.out.println("Dijkstra et Bellman Ford ont le meme path\n ");
+            System.out.println("Dijkstra et Astar ont le meme path\n ");
     }
-    else{System.out.println("Dijkstra et Bellman Ford ne donnent pas le même path\n ");} 
+    else{System.out.println("Dijkstra et Astar ne donnent pas le même path\n ");} 
     System.out.println("---------------------------------------------------\n ");
 
     // cPath est faisable
     System.out.println("---------------------------------------------------\n ");
-        System.out.println("Test faisabilite path Bellman-Ford et Dijkstra\n ");
-        if(SolutionInfaisableDijkstra(Data4)){
-            System.out.println("Dijkstra infaisable :erreur \n ");
+        System.out.println("Test faisabilite path Astar et Dijkstra\n ");
+        if(SolutionInfaisableAstar(Data4)){
+            System.out.println("Astar infaisable :erreur \n ");
     }
-    else{System.out.println("Dijkstra faisable : bon \n ");} 
+    else{System.out.println("Astar faisable : bon \n ");} 
     System.out.println("---------------------------------------------------\n ");
 
     // cas 5 : Origine et Destination sont les memes donc path faisable mais cout nul
-     // Recuperation du path realise par Dijkstra
+     // Recuperation du path realise par Astar
         ShortestPathData Data5 = new ShortestPathData(graph,pathrecupere1.getOrigin(), pathrecupere1.getOrigin(),OnlyPedestrianByTime);
         // verification du fait qu'on n'a pas de chemin
-        DijkstraAlgorithm algo = new DijkstraAlgorithm(Data5);
+        DijkstraAlgorithm algo = new AStarAlgorithm(Data5);
         ShortestPathSolution solution = algo.run();
         // Affichage des résultats
         System.out.println("Statut : " + solution.getStatus());
@@ -470,15 +482,15 @@ System.out.println("---------------------------------------------------\n ");
 
     // Cas 6: deux composantes non connexes 
         Graph graph2 = graphlecture(mapName5);
-         // Recuperation du path realise par Dijkstra
+         // Recuperation du path realise par Astar
         ShortestPathData Data6 = new ShortestPathData(graph,graph.get(63), graph.get(1253),OnlyPedestrianByTime);
         // verification du fait qu'on n'a pas de chemin
         System.out.println("---------------------------------------------------\n ");
         System.out.println("Test Solution Infaisable\n ");
-        if(SolutionInfaisableDijkstra(Data6)){
-            System.out.println("L'algorithme Dijkstra donne le bon path : infaisable\n ");
+        if(SolutionInfaisableAstar(Data6)){
+            System.out.println("L'algorithme Astar donne le bon path : infaisable\n ");
         } 
-        else{System.out.println("L'algorithme Dijkstra ne donne pas le bon path\n");} 
+        else{System.out.println("L'algorithme Astar ne donne pas le bon path\n");} 
         System.out.println("---------------------------------------------------\n ");
     // Cas 7 : trajet grande map
     Graph graph3 = graphlecture(mapName3);
@@ -488,12 +500,12 @@ System.out.println("---------------------------------------------------\n ");
         // verification du fait qu'on n'a pas de chemin
         System.out.println("---------------------------------------------------\n ");
         System.out.println("Test Solution Faisable\n ");
-        if(SolutionInfaisableDijkstra(Data7)){
-            System.out.println("L'algorithme Dijkstra donne le mauvais path : infaisable\n ");
+        if(SolutionInfaisableAstar(Data7)){
+            System.out.println("L'algorithme Astar donne le mauvais path : infaisable\n ");
         } 
-        else{System.out.println("L'algorithme Dijkstra donne le bon path\n");} 
+        else{System.out.println("L'algorithme Astar donne le bon path\n");} 
         System.out.println("---------------------------------------------------\n ");
-        DijkstraAlgorithm algo2 = new DijkstraAlgorithm(Data7);
+        AStarAlgorithm algo2 = new AStarAlgorithm(Data7);
         ShortestPathSolution solution2 = algo2.run();
         System.out.println("cout chemin:" +solution2.getPath().getLength());
         System.out.println("temps chemin:"+solution2.getPath().getMinimumTravelTime());