BE_graphes/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithmTest.java

package org.insa.graphs.algorithm.shortestpath;

import static org.junit.Assert.*;

import org.insa.graphs.*;//voir si on ne peut pas importer launch autrement

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

import org.insa.graphs.algorithm.ArcInspector;
import org.insa.graphs.algorithm.ArcInspectorFactory;
import org.insa.graphs.model.*;
import org.insa.graphs.model.RoadInformation.RoadType;
import org.insa.graphs.model.io.BinaryGraphReader;
import org.insa.graphs.model.io.BinaryPathReader;
import org.junit.BeforeClass;
import org.junit.Test;

public class DijkstraAlgorithmTest{
	
	//copié sur PathTest.java
	// Small graph use for tests
    private static Graph graph;

    // List of nodes
    private static Node[] nodes;

    // List of arcs in the graph, a2b is the arc from node A (0) to B (1).
    @SuppressWarnings("unused")
    private static Arc ab, ac, ad, bf, bd, cd, cg, df, de, de2, dh, ef, eg, eh, fg, gh;

    private static ShortestPathData dataal, datacl, dataat, datact, datapt, onenodata, emptydata, invalidata;
    
	// permet de savoir quels arcs autoriser(cf l.187 excel ggdoc)
    private static ArcInspector alllen = ArcInspectorFactory.getAllFilters().get(0);
    private static ArcInspector carlen = ArcInspectorFactory.getAllFilters().get(1);
    private static ArcInspector alltime = ArcInspectorFactory.getAllFilters().get(2);
    private static ArcInspector cartime = ArcInspectorFactory.getAllFilters().get(3);
    private static ArcInspector pietime = ArcInspectorFactory.getAllFilters().get(4);
    
	private static DijkstraAlgorithm dijkal, dijkcl, dijkat, dijkct, dijkpt, onenodijk, emptydijk, invalidijk;
	private static BellmanFordAlgorithm bfaal, bfacl, bfaat, bfact, bfapt;
    
    
    @BeforeClass
    public static void initAll() throws IOException {

        RoadInformation speed10 = new RoadInformation(RoadType.MOTORWAY, null, true, 36, ""),
                speed20 = new RoadInformation(RoadType.MOTORWAY, null, true, 72, ""),
                pietonable = new RoadInformation(RoadType.PEDESTRIAN, null, true, 5, "");
        //cyclable = new RoadInformation(RoadType.CYCLEWAY, null, true, 20, ""),

        // Create nodes
        nodes = new Node[8];
        for (int i = 0; i < nodes.length; ++i) {
            nodes[i] = new Node(i, null);
        }

        // définition des arcs
        ab = Node.linkNodes(nodes[0], nodes[1], 10, speed10, null);
        ac = Node.linkNodes(nodes[0], nodes[2], 50, speed20, null);
        ad = Node.linkNodes(nodes[0], nodes[3], 15, speed10, null);
        bd = Node.linkNodes(nodes[1], nodes[3], 15, speed20, null);
        bf = Node.linkNodes(nodes[1], nodes[5], 20, speed10, null);
        cd = Node.linkNodes(nodes[2], nodes[3], 10, speed20, null);
        cg = Node.linkNodes(nodes[2], nodes[6], 15, speed10, null);
        de = Node.linkNodes(nodes[3], nodes[4], 15, speed20, null);
        de2= Node.linkNodes(nodes[3], nodes[4], 25, pietonable, null);
        df = Node.linkNodes(nodes[3], nodes[5], 8, pietonable, null);
        dh = Node.linkNodes(nodes[3], nodes[7], 12, pietonable, null);
        ef = Node.linkNodes(nodes[4], nodes[5], 10, speed10, null);
        eg = Node.linkNodes(nodes[4], nodes[6], 10, speed20, null);
        eh = Node.linkNodes(nodes[4], nodes[7], 5, pietonable, null);
        fg = Node.linkNodes(nodes[5], nodes[6], 10, pietonable, null);
        gh = Node.linkNodes(nodes[6], nodes[7], 12, pietonable, null);       
        
        
        graph = new Graph("ID", "", Arrays.asList(nodes), null);

        //initialisation des datas
        dataal= new ShortestPathData(graph, nodes[0], nodes[4], alllen);//a->e
        datacl= new ShortestPathData(graph, nodes[0], nodes[0], carlen);//b->g
        dataat= new ShortestPathData(graph, nodes[0], nodes[0], alltime);//h->b
        datact= new ShortestPathData(graph, nodes[0], nodes[0], cartime);//c->b
        datapt= new ShortestPathData(graph, nodes[5], nodes[0], pietime);//f->e
        onenodata=new ShortestPathData(graph, nodes[2], nodes[2], pietime);
        emptydata=new ShortestPathData(graph, null, null, pietime);
        invalidata=new ShortestPathData(graph, nodes[0], nodes[7], carlen);//h accessible uniquement aux piétons
        
        //initialisation des Dijkstras
        dijkal=new DijkstraAlgorithm(dataal);
        dijkcl=new DijkstraAlgorithm(datacl);
        dijkat=new DijkstraAlgorithm(dataat);
        dijkct=new DijkstraAlgorithm(datact);
        dijkpt=new DijkstraAlgorithm(datapt);
        onenodijk=new DijkstraAlgorithm(onenodata);
        emptydijk=new DijkstraAlgorithm(emptydata);
        invalidijk=new DijkstraAlgorithm(invalidata);
        
        //initialisation des Bellman-Ford pour comparaison
		bfaal=new BellmanFordAlgorithm(dataal);
		bfacl=new BellmanFordAlgorithm(datacl);
		bfaat=new BellmanFordAlgorithm(dataat);
		bfact=new BellmanFordAlgorithm(datact);
		bfapt=new BellmanFordAlgorithm(datapt);

    }    

    //créer plus et avec des maps différentes
    //faire des test spécifiques pour longs trajets
   
	
	/*(Test faits directement via la console et DijkstraAlgorithm.java, actuellement commentés:
	-coûts croissants
	-nbr successeurs cohérents
	-tas valide.)*/
	
	@Test
	public void cheminValide() {
		assertTrue(dijkal.doRun().getPath().isValid());
		assertTrue(dijkcl.doRun().getPath().isValid());
		assertTrue(dijkat.doRun().getPath().isValid());
		assertTrue(dijkct.doRun().getPath().isValid());
		assertTrue(dijkpt.doRun().getPath().isValid());
		assertTrue(onenodijk.doRun().getPath().isValid());
		assertTrue(emptydijk.doRun().getPath().isValid());//pas sûr
		assertFalse(invalidijk.doRun().getPath().isValid());
	}
	
	@Test
	public void faisable() {
		assertTrue(dijkal.doRun().isFeasible());
		assertTrue(dijkcl.doRun().isFeasible());
		assertTrue(dijkat.doRun().isFeasible());
		assertTrue(dijkct.doRun().isFeasible());
		assertTrue(dijkpt.doRun().isFeasible());
		assertTrue(onenodijk.doRun().isFeasible());
		assertFalse(emptydijk.doRun().isFeasible());//pas sûr
		assertFalse(invalidijk.doRun().isFeasible());	
	}
	
	
	//résultat identique à Bellman-Ford (sur les petits scénarios)
	@Test
	public void sameasBF() {//peut-être faut-il donner directement par exemple à dijkal dijkal.doRun() pour éviter de la surexécution
		//voir alors comment gérer les erreurs (pas encore gérées ici)
		assertTrue(Float.compare(dijkal.doRun().getPath().getLength(),bfaal.doRun().getPath().getLength())==0);
		assertTrue(Float.compare(dijkcl.doRun().getPath().getLength(),bfacl.doRun().getPath().getLength())==0);
		assertTrue(Double.compare(dijkat.doRun().getPath().getMinimumTravelTime(),bfaat.doRun().getPath().getMinimumTravelTime())==0);
		assertTrue(Double.compare(dijkct.doRun().getPath().getMinimumTravelTime(),bfact.doRun().getPath().getMinimumTravelTime())==0);
		assertTrue(Double.compare(dijkpt.doRun().getPath().getMinimumTravelTime(),bfapt.doRun().getPath().getMinimumTravelTime())==0);
	}
	
	//grands scénarios:	
	public void testmap() throws FileNotFoundException, IOException{//A FAIRE
		
		String mapaddr = "/home/favary/Bureau/commetud/3eme Annee MIC/Graphes-et-Algorithmes/Maps/haute-garonne.mapgr";
		String pathaddr ="/home/favary/Bureau/commetud/3eme Annee MIC/Graphes-et-Algorithmes/Paths/path_fr31_insa_aeroport_length.path";
				
		Graph graphmap = (new BinaryGraphReader(new DataInputStream(new BufferedInputStream(new FileInputStream(mapaddr))))).read();
		Path pathmap = (new BinaryPathReader(new DataInputStream(new BufferedInputStream(new FileInputStream(pathaddr))))).readPath(graphmap);
		//quel inspector prendre? Le path est en longueur mais voitures seulement ou tout autorisé?
		
		DijkstraAlgorithm dijkmap = new DijkstraAlgorithm(new ShortestPathData(graphmap, pathmap.getOrigin(), pathmap.getDestination(), alllen));
	
		assertTrue(dijkmap.doRun().getPath().getLength()==pathmap.getLength());
		//comparaison de la longueur
	}
}