From 2ec3d4200f9ea5e3ff6aa46f75d341ddd5db93a1 Mon Sep 17 00:00:00 2001
From: Clement LACAU <lacau@insa-toulouse.fr>
Date: Mon, 20 May 2024 00:31:13 +0200
Subject: [PATCH] Edge case fix + Astar Time mode

---
 Synthese_LACAU_ALNET.docx                     | Bin 0 -> 12491 bytes
 .../shortestpath/AStarAlgorithm.java          |  12 +-
 .../shortestpath/DijkstraAlgorithm.java       |  11 +-
 .../graphs/algorithm/shortestpath/Label.java  |   4 +-
 .../algorithm/shortestpath/LabelStar.java     |  14 +-
 .../shortestpath/AStarAlgorithmTest.java      | 416 ++++++++++++++++++
 .../shortestpath/DijkstraAlgorithmTest.java   |   3 -
 7 files changed, 446 insertions(+), 14 deletions(-)
 create mode 100644 Synthese_LACAU_ALNET.docx
 create mode 100644 be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithmTest.java

diff --git a/Synthese_LACAU_ALNET.docx b/Synthese_LACAU_ALNET.docx
new file mode 100644
index 0000000000000000000000000000000000000000..cf5339eb1423b42b094b901fc75ce3a555d0bc84
GIT binary patch
literal 12491
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

literal 0
HcmV?d00001

diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
index 0cc39a7..88d1dfa 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
@@ -1,13 +1,21 @@
 package org.insa.graphs.algorithm.shortestpath;
 
+import org.insa.graphs.algorithm.AbstractInputData.Mode;
 import org.insa.graphs.model.Node;
 
 public class AStarAlgorithm extends DijkstraAlgorithm {
     private Node destination;
-
+    
     @Override
     protected Label createLabel(Node node) {
-        return new LabelStar(node, destination);
+        LabelStar retour;
+        if (data.getMode() == Mode.LENGTH) {
+            retour = new LabelStar(node, -1, destination);
+        }
+        else {
+            retour = new LabelStar(node, data.getGraph().getGraphInformation().getMaximumSpeed(), destination);
+        }
+        return retour;
     }
 
     public AStarAlgorithm(ShortestPathData data) {
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
index 36cc09b..47c7b0f 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
@@ -74,15 +74,19 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
                     // we know its origin and destination
                     for (Arc arc : x.getNode().getSuccessors()) {
                         if (successor.getNode().equals(arc.getDestination())) {
+                            // data.getcost(arc) returns a cost considering the mode chosen:
+                            // TIME or LENGTH
+                            // Similar to using getLength / getMinimumTravelTime
                             arc_cost = (float) data.getCost(arc);
                         }
                     }
+                    
                     final float possible_path_cost = x.getCost() + arc_cost;
-                    if (successor.getCost() > possible_path_cost) {
+                    if (successor.getCost() >= possible_path_cost) {
                         // Mise à jour du label
                         successor.setPathCost(possible_path_cost);
                         successor.setParentNode(x.getNode());
-                        // Si le noeud n'a pas déjà était rajouté au tas, on le rajoute
+                        // Si le noeud n'a pas déjà été rajouté au tas, on le rajoute
                         // isReached permet de vérifier en complexité O(1)
                         // C'est un léger coût en mémoire pour un gain en vitesse
                         if (successor.isReached()) {
@@ -92,7 +96,6 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
                             successor.markReached();
                             notifyNodeReached(successor.getNode());
                         }
-
                         tas.insert(successor);
                     }
                 }
@@ -112,7 +115,7 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
         Label current_label = labels.get(data.getDestination().getId());
         Label parent_label = current_label;
 
-        while(current_label != null && current_label.getNode() != data.getOrigin())
+        while(current_label != null && current_label.getNode().getId() != data.getOrigin().getId())
         {
             // Find the label matching the parent node
             parent_label = labels.get(current_label.getParentNode().getId());
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/Label.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/Label.java
index ffdf560..bdc3da7 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/Label.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/Label.java
@@ -1,6 +1,7 @@
 package org.insa.graphs.algorithm.shortestpath;
 
 import org.insa.graphs.model.Node;
+import org.insa.graphs.algorithm.AbstractInputData.Mode;
 
 public class Label implements Comparable<Label> {
   Node node;
@@ -30,6 +31,7 @@ public class Label implements Comparable<Label> {
 
   public float getCost() {
     // function will be modified later
+    
     return pathCost;
   }
 
@@ -41,7 +43,5 @@ public class Label implements Comparable<Label> {
   public int compareTo(Label other) {
     final float difference = this.getTotalCost() - other.getTotalCost();
     return (int) Math.signum(difference);
-    // Note that doesn't address the requested condition regarding equality :
-    // "En cas d'égalité, on considèrera en premier le sommet ayant le plus petit coût estimé à la destination."
   }
 }
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelStar.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelStar.java
index 232d1d1..4c03d2c 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelStar.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/LabelStar.java
@@ -2,17 +2,25 @@ package org.insa.graphs.algorithm.shortestpath;
 
 import org.insa.graphs.model.Node;
 import org.insa.graphs.model.Point;
+import org.insa.graphs.algorithm.AbstractInputData.Mode;
+import org.insa.graphs.model.RoadInformation;
 
 public class LabelStar extends Label {
   private float distanceToDestination;
+  private int MaximumSpeed;
 
-  public LabelStar(Node node, Node destination) {
+  public LabelStar(Node node, int MaximumSpeed, Node destination) {
     super(node);
+    this.MaximumSpeed = MaximumSpeed;
     // precision was never an answer
-    distanceToDestination = (float) Point.distance(node.getPoint(), destination.getPoint());
+    if (this.MaximumSpeed < 0) {
+      distanceToDestination = (float) Point.distance(node.getPoint(), destination.getPoint());
+    }
+    else {
+      distanceToDestination = (float) Point.distance(node.getPoint(), destination.getPoint()) / (1000 * MaximumSpeed);
+    }
   }
 
-
   @Override
   public float getTotalCost() {
     return this.getCost() + distanceToDestination;
diff --git a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithmTest.java b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithmTest.java
new file mode 100644
index 0000000..db9ac71
--- /dev/null
+++ b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithmTest.java
@@ -0,0 +1,416 @@
+package org.insa.graphs.algorithm.shortestpath;
+
+import static org.junit.Assert.*;
+
+import java.io.BufferedInputStream;
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import org.insa.graphs.algorithm.ArcInspector;
+import org.insa.graphs.algorithm.ArcInspectorFactory;
+import org.insa.graphs.model.Graph;
+import org.insa.graphs.model.Node;
+import org.insa.graphs.model.Path;
+import org.insa.graphs.model.io.BinaryGraphReader;
+import org.insa.graphs.model.io.GraphReader;
+import org.insa.graphs.model.io.PathReader;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runners.Parameterized.Parameter;
+
+public class AStarAlgorithmTest {
+
+    public static GraphReader reader;
+    public static ArrayList<Graph> graph = new ArrayList<Graph>();
+    public static PathReader pathReader;
+    public static ArrayList<Path> path = new ArrayList<Path>();
+
+    @Parameter
+    // Liste de cartes utilisées
+    static ArrayList<String> Maps = new ArrayList<String>(Arrays.asList("../Maps/carre.mapgr",
+                                                                            "../Maps/insa.mapgr",
+                                                                            "../Maps/toulouse.mapgr",
+                                                                            "../Maps/midi-pyrenees.mapgr"));
+
+    @BeforeClass
+    /* 
+     * Ajoute toute les cartes dans l'attribut graph.
+     * Ensuite, on testera des chemins dont qui sont disponibles dans custom_path.
+     * Ces chemins ont été tracés avec l'algo BellmanFord et sont donc considérés corrects.
+     * On ne crée pas les chemins dans un attribut, on va les "recréer" virtuellement à
+     * partir de leur origine/destination et en appliquant BellmanFord.
+     * Cela permet une meilleure adaptabilité du code.
+    */
+    public static void init() {
+        try {
+            // Create the map
+            for (int j = 0 ; j < Maps.size() ; j++) {
+                final String mapName = Maps.get(j);
+                // Create a graph reader
+                final GraphReader reader = new BinaryGraphReader(
+                    new DataInputStream(new BufferedInputStream(new FileInputStream(mapName))));
+                // Read the graph. X
+                graph.add(reader.read());
+                // free resources
+                reader.close();
+                }
+            }
+        catch (FileNotFoundException e) {
+            System.err.println("File not found: " + e.getMessage());
+            fail("File not found: " + e.getMessage());
+        }
+        catch (IOException e ) {
+            System.err.println("Error reading file: " + e.getMessage());
+            fail("Error reading file: " + e.getMessage());
+        }
+    }
+
+    
+    /* Stratégie:
+     * Chemins courts testés par comparaison avec Bellman.
+     * Chemin longs testés par comparaison avec chemins déjà construits. Bellman trop long.
+     */
+    
+    @Test
+    /* 
+     * Map: carre.mapgr
+     * Chemin: 19 --> 4
+     * Tous chemins permis
+     * Mode: LENGTH
+     * PATH UTILISE : ../Paths/custom_paths/short_path_carre.path
+    */
+    public void chemin_court_CARRE_length() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
+        Graph myGraph = graph.get(0);
+        Node origin = myGraph.get(19);
+        Node destination = myGraph.get(4);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+
+        BellmanFordAlgorithm bellman = new BellmanFordAlgorithm(data);
+        ShortestPathSolution bell_path = bellman.doRun();
+
+        assert(astar_path.getPath().isValid());
+        assert(astar_path.isFeasible());
+        assert(Math.abs(astar.getCostPath() - astar_path.getPath().getLength()) < 1.0);
+        assert(Math.abs(astar_path.getPath().getLength() - bell_path.getPath().getLength()) < 1.0);
+    }
+
+    @Test
+    /*
+    * Chemin long relativement à la carte carrée.
+    * Chemin: 15 --> 9
+    * Tous chemins permis
+    * PATH UTILISE : ../Paths/custom_paths/long_path_carre.path
+    */
+    public void chemin_long_CARRE_length() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
+        Graph myGraph = graph.get(0);
+        Node origin = myGraph.get(15);
+        Node destination = myGraph.get(9);
+
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+
+        BellmanFordAlgorithm bellman = new BellmanFordAlgorithm(data);
+        ShortestPathSolution bell_path = bellman.doRun();
+
+        assert(astar_path.getPath().isValid());
+        assert(astar_path.isFeasible());
+        assert(Math.abs(astar.getCostPath() - astar_path.getPath().getLength()) < 1.0);
+        assert(Math.abs(astar_path.getPath().getLength() - bell_path.getPath().getLength()) < 1.0);
+    }
+
+
+    @Test
+    /*
+     * Chemin nul sur carte carrée.
+     * L'origine et la destination sont les mêmes (noeud 3).
+     * Tous chemins permis
+     */
+    public void chemin_nul_CARRE() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
+        Graph myGraph = graph.get(0);
+        Node origin = myGraph.get(3);
+        Node destination = myGraph.get(3);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+
+        assert(!astar_path.isFeasible());
+        assert(astar_path.getPath() == null);
+    }
+
+    @Test
+    /*
+     * Chemin inexistant sur la carte INSA.
+     * Origine: 224
+     * Destination: 814.
+     * Les 2 noeuds font partie de deux composantes non connexes.
+     * Tous chemins permis.
+    */
+    public void chemin_inexistant_INSA() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
+        Graph myGraph = graph.get(1);
+        Node origin = myGraph.get(224);
+        Node destination = myGraph.get(814);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+        assert(!astar_path.isFeasible());
+        assert(astar_path.getPath() == null);
+    }
+
+    @Test
+    /*
+     * Chemin court sur la carte de Toulouse.
+     * Origine : 8423 
+     * Destination: 8435
+     * Tous chemins permis.
+     * PATH UTILISE : ../Paths/custom_paths/short_path_tls.path
+     */
+    public void chemin_court_TLS() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
+        Graph myGraph = graph.get(2);
+        Node origin = myGraph.get(8423);
+        Node destination = myGraph.get(8435);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+
+        BellmanFordAlgorithm bellman = new BellmanFordAlgorithm(data);
+        ShortestPathSolution bell_path = bellman.doRun();
+
+        assert(astar_path.getPath().isValid());
+        assert(astar_path.isFeasible());
+        assert(Math.abs(astar.getCostPath() - astar_path.getPath().getLength()) < 1.0);
+        assert(Math.abs(astar_path.getPath().getLength() - bell_path.getPath().getLength()) < 1.0);
+    }
+
+    @Test
+    /*
+     * Chemin long sur la carte de Toulouse.
+     * Même si Bellman est de plus long à faire long à faire, ce test prend moins
+     * de 3s, on estime que ce n'est pas trop et on va utiliser Bellman.
+     * Par contre, dans le test sur la région midi_pyrenees qui arrive après, on va
+     * être obligé de trouver une autre solution.
+     * Origine: 16644
+     * Destination: 39229
+     * Mode: LENGTH
+     * PATH UTILISE : ../Paths/custom_paths/long_path_tls.path
+     */
+    public void chemin_long_TLS_length() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
+        Graph myGraph = graph.get(2);
+        Node origin = myGraph.get(16644);
+        Node destination = myGraph.get(39229);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+
+        BellmanFordAlgorithm bellman = new BellmanFordAlgorithm(data);
+        ShortestPathSolution bell_path = bellman.doRun();
+        
+        assert(astar_path.getPath().isValid());
+        assert(astar_path.isFeasible());
+        assert((Math.abs(astar.getCostPath() - astar_path.getPath().getLength()) < 1.0));
+        assert(Math.abs(astar_path.getPath().getLength() - bell_path.getPath().getLength()) < 10.0);
+    }
+
+
+    @Test
+    /*
+     * Chemin long sur la carte de Toulouse.
+     * Comme à cette étape Dijkstra a été testé, on va l'utiliser pour vérifier
+     * AStar. On considère que Dijkstra est correct et vérifié.
+     * Origine: 16644
+     * Destination: 39229
+     * Mode: TIME
+     * PATH UTILISE : ../Paths/custom_paths/long_path_tls.path
+     */
+    public void chemin_long_TLS_time() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(2);
+        Graph myGraph = graph.get(2);
+        Node origin = myGraph.get(16644);
+        Node destination = myGraph.get(39229);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+
+        DijkstraAlgorithm dijkstra = new DijkstraAlgorithm(data);
+        ShortestPathSolution dijkstra_path = dijkstra.doRun();
+        
+        assert(astar_path.getPath().isValid());
+        assert(astar_path.isFeasible());
+        assert((Math.abs(astar.getCostPath() - astar_path.getPath().getMinimumTravelTime()) < 1.0));
+        assert(Math.abs(astar.getCostPath() - dijkstra.getCostPath()) < 1.0 );
+    }
+
+    @Test
+    /*
+     * Test du mode à vélo facultatif.
+     * Nous prenons une origine sur l'autoroute et une destination en dehors.
+     * Ce chemin est donc censé être utilisable en vélo mais pas en voiture.
+     * Avec le filtre vélos, on obtient pas de chemin.
+     * Avec le filtre voitures on obtient un chemin.
+     * Origine: 19135
+     * Destination: 1980
+     * PATH UTILISE : ../Paths/custom_paths/path_cyclist.path
+     */
+    public void chemin_velo_uniquement() {
+        // Filter: forBicyclesCustomT
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(4);
+        
+        Graph myGraph = graph.get(2);
+        Node origin = myGraph.get(19135);
+        Node destination = myGraph.get(1980);
+
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar_bicycle = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path_bicycle = astar_bicycle.doRun();
+        
+        BellmanFordAlgorithm bellman_bicycle = new BellmanFordAlgorithm(data);
+        ShortestPathSolution bell_path_bicycle = bellman_bicycle.doRun();
+
+        // Filter: forCarsL
+        ArcInspector new_Inspector = ArcInspectorFactory.getAllFilters().get(1);
+        data = new ShortestPathData(myGraph, origin, destination, new_Inspector);
+
+        AStarAlgorithm astar_car = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path_car = astar_car.doRun();
+
+        assertEquals(astar_path_bicycle.getPath(), null);
+        assert(!astar_path_bicycle.isFeasible());
+        assertEquals(bell_path_bicycle.getPath(), null);
+        assert(!bell_path_bicycle.isFeasible());
+        
+        assert(astar_path_car.getPath() != null);
+        assert(astar_path_car.isFeasible());
+    }
+
+    @Test
+    /*
+     * On veut vérifier le bon fonctionnement des modes TIME et LENGTH. 
+     * Pour cela, on va obtenir deux chemins avec l'algo de astar et vérifier
+     * que:
+     * -le chemin TIME est plus rapide en durée que le chemin LENGTH
+     * -le chemin LENGTH est plus court en distance que le chemin LENGTH.
+     * On prend un grand chemin pour être sur d'avoir une différence :
+     * Origine: 16644
+     * Destination: 39229
+     * Mode: TIME/LENGTH
+     * PATH UTILISE : ../Paths/custom_paths/long_path_tls.path
+     */
+    public void chemin_time_length_comparison() {
+        Graph myGraph = graph.get(2);
+        Node origin = myGraph.get(19135);
+        Node destination = myGraph.get(1980);
+        
+        // Filter: forCarsL
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(1);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar_L = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path_L = astar_L.doRun();
+
+        // Filter: forCarsT
+        ArcInspector new_Inspector = ArcInspectorFactory.getAllFilters().get(2);
+        data = new ShortestPathData(myGraph, origin, destination, new_Inspector);
+
+        AStarAlgorithm astar_T = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path_T = astar_T.doRun();
+
+        assert(astar_path_L.getPath().isValid());
+        assert(astar_path_L.isFeasible());
+        assert(astar_path_T.getPath().isValid());
+        assert(astar_path_T.isFeasible());
+
+        assert((Math.abs(astar_L.getCostPath() - astar_path_L.getPath().getLength()) < 1.0));
+        assert((Math.abs(astar_T.getCostPath() - astar_path_T.getPath().getMinimumTravelTime()) < 1.0));
+
+        assert(astar_path_L.getPath().getLength() < astar_path_T.getPath().getLength());
+        assert(astar_path_L.getPath().getMinimumTravelTime() > astar_path_T.getPath().getMinimumTravelTime());
+    }
+
+    @Test
+    /*
+     * Cette fois-ci, Bellman est trop long à utiliser même une seule fois.
+     * On va donc utiliser quelques techniques pour se rassurer.
+     * -vérifier certains noeuds comme départ, destination, noeud pivot.
+     * -vérifier le cout avec une estimation gentille.
+     * -etc.
+     * Origin: 279654
+     * Destination: 481936
+     * Mode: LENGTH
+     * PATH UTILISE : ../Paths/custom_paths/long_chemin_midi_pyrenees.path
+     */
+    public void chemin_long_Midi_pyrenees_length() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
+        Graph myGraph = graph.get(3);
+        Node origin = myGraph.get(279654);
+        Node destination = myGraph.get(481936);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+
+        assert(astar_path.getPath().isValid());
+        assert(astar_path.isFeasible());
+        // On a des erreurs d'arrondi assez grande avec la distance, mais elles sont mineures
+        // relativement aux distance de 300000 ici.
+        assert((Math.abs(astar.getCostPath() - astar_path.getPath().getLength())) < 1000.0);
+        // Selon le chemin sélectionné on peut avoir une estimation de la longueur qu'on est censée avoir.
+        // Avec notre long chemin: entre 250 et 260 kilomètres.
+        assert(astar.getCostPath() > 250000 && astar.getCostPath() < 260000);
+        // On peut aussi supposer que le nombre d'arcs empruntés est très grand.
+        assert(astar_path.getPath().getArcs().size() > 1000);
+    }
+    
+    @Test
+    /*
+     * Cette fois-ci, Bellman est trop long à utiliser même une seule fois.
+     * On va donc utiliser quelques techniques pour se rassurer.
+     * -vérifier certains noeuds comme départ, destination, noeud pivot.
+     * -vérifier le cout avec une estimation gentille.
+     * -etc.
+     * Origin: 279654
+     * Destination: 481936
+     * Mode: LENGTH
+     * PATH UTILISE : ../Paths/custom_paths/long_chemin_midi_pyrenees.path
+     */
+    public void chemin_long_Midi_pyrenees_time() {
+        ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(2);
+        Graph myGraph = graph.get(3);
+        Node origin = myGraph.get(279654);
+        Node destination = myGraph.get(481936);
+        ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
+        
+        AStarAlgorithm astar = new AStarAlgorithm(data);
+        ShortestPathSolution astar_path = astar.doRun();
+
+        assert(astar_path.getPath().isValid());
+        assert(astar_path.isFeasible());
+        // On a des erreurs d'arrondi assez grandes avec la distance
+        assert((Math.abs(astar.getCostPath() - astar_path.getPath().getMinimumTravelTime())) < 100.0);
+        // Selon le chemin sélectionné on peut avoir une estimation de la durée qu'on est censée avoir.
+        // Avec notre long chemin: entre 12000 et 13000 secondes.
+        assert(astar.getCostPath() > 12000 && astar.getCostPath() < 13000);
+        // On peut aussi supposer que le nombre d'arcs empruntés est très grand.
+        assert(astar_path.getPath().getArcs().size() > 1000);
+    }
+
+}
diff --git a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithmTest.java b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithmTest.java
index 649dd68..bd9586f 100644
--- a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithmTest.java
+++ b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithmTest.java
@@ -24,7 +24,6 @@ import org.junit.runners.Parameterized.Parameter;
 
 public class DijkstraAlgorithmTest {
 
-    // TODO finish this
     public static GraphReader reader;
     public static ArrayList<Graph> graph = new ArrayList<Graph>();
     public static PathReader pathReader;
@@ -48,7 +47,6 @@ public class DijkstraAlgorithmTest {
     */
     public static void init() {
         try {
-            ArrayList<String> actual_path_list = new ArrayList<String>();
             // Create the map
             for (int j = 0 ; j < Maps.size() ; j++) {
                 final String mapName = Maps.get(j);
@@ -76,7 +74,6 @@ public class DijkstraAlgorithmTest {
      * Chemins courts testés par comparaison avec Bellman.
      * Chemin longs testés par comparaison avec chemins déjà construits. Bellman trop long.
      */
-    // TODO
     
     @Test
     /*