/*

     This file is part of Combean.

     Combean is free software; you can redistribute it and/or modify

     it under the terms of the GNU General Public License as published by

     the Free Software Foundation; either version 2 of the License, or

     (at your option) any later version.

     Combean is distributed in the hope that it will be useful,

     but WITHOUT ANY WARRANTY; without even the implied warranty of

     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License

     along with Combean; if not, write to the Free Software

     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

 /*

  * Created on 20.08.2005

  *

  */

 package net.sourceforge.combean.test.graph.alg.traversal;

 import junit.framework.TestCase;

 import net.sourceforge.combean.graph.alg.traversal.FindPathByTraversalAlg;

 import net.sourceforge.combean.interfaces.graph.Node;

 import net.sourceforge.combean.interfaces.graph.NodeIterator;

 import net.sourceforge.combean.interfaces.graph.containers.FixedPath;

 import net.sourceforge.combean.interfaces.graph.prop.GlobalNumberedGraphProp;

 import net.sourceforge.combean.test.helpers.factories.GraphFixtureFactory;

 /**

  * @author schickin

  *

  */

 public class TestFindPathByTraversalAlg extends TestCase {

     private static final int NUMNODES = 9;

     GlobalNumberedGraphProp path = null;

     GlobalNumberedGraphProp cycle = null;

     private FindPathByTraversalAlg findPathAlg = null;

     public static void main(String[] args) {

         junit.textui.TestRunner.run(TestFindPathByTraversalAlg.class);

     }

     /*

      * @see TestCase#setUp()

      */

     protected void setUp() throws Exception {

         super.setUp();

         this.path = GraphFixtureFactory.createDirectedPath(NUMNODES);

         this.cycle = GraphFixtureFactory.createDirectedCycle(NUMNODES);

         this.findPathAlg = new FindPathByTraversalAlg();

     }

     /*

      * @see TestCase#tearDown()

      */

     protected void tearDown() throws Exception {

         super.tearDown();

     }

     /**

      * Constructor for TestFindPathByTraversalAlg.

      * @param name

      */

     public TestFindPathByTraversalAlg(String name) {

         super(name);

     }

     public final void testUnreachableNode() {

         this.findPathAlg.setGraph(this.path);

         this.findPathAlg.setUseOutgoingEdgesOnly(true);

         Node s = this.path.getNode(1);

         Node t = this.path.getNode(0);

         this.findPathAlg.setStartNode(s);

         this.findPathAlg.setTargetNode(t);

         this.findPathAlg.run();

         FixedPath p = this.findPathAlg.getPathTo(t);

         assertNull("no path may have been found", p);

     }

     public final void testFindPathInDirectedPath() {

         this.findPathAlg.setGraph(this.path);

         this.findPathAlg.setUseOutgoingEdgesOnly(true);

         Node s = this.path.getNode(1);

         Node t = this.path.getNode(NUMNODES-2);

         this.findPathAlg.setStartNode(s);

         this.findPathAlg.setTargetNode(t);

         this.findPathAlg.run();

         FixedPath p = this.findPathAlg.getPathTo(t);

         assertNotNull(p);

         NodeIterator itNodesInPath = p.getNodeIterator();

         int currNodeNum = 1;

         while (itNodesInPath.hasNext()) {

             Node v = itNodesInPath.next();

             assertEquals(currNodeNum++, this.path.getNodeNumber(v));

         }

         assertEquals(NUMNODES-1, currNodeNum);

     }

     public final void testFindPathInUndirectedPath() {

         this.findPathAlg.setGraph(this.path);

         this.findPathAlg.setUseOutgoingEdgesOnly(false);

         Node s = this.path.getNode(NUMNODES-2);

         Node t = this.path.getNode(1);

         this.findPathAlg.setStartNode(s);

         this.findPathAlg.setTargetNode(t);

         this.findPathAlg.run();

         FixedPath p = this.findPathAlg.getPathTo(t);

         assertNotNull(p);

         NodeIterator itNodesInPath = p.getNodeIterator();

         int currNodeNum = NUMNODES-2;

         while (itNodesInPath.hasNext()) {

             Node v = itNodesInPath.next();

             assertEquals(currNodeNum--, this.path.getNodeNumber(v));

         }

         assertEquals(0, currNodeNum);

     }

     public final void testFindPathInCycle() {

         this.findPathAlg.setGraph(this.cycle);

         this.findPathAlg.setUseOutgoingEdgesOnly(false);

         Node s = this.cycle.getNode(1);

         Node t = this.cycle.getNode(NUMNODES-2);

         this.findPathAlg.setStartNode(s);

         this.findPathAlg.setTargetNode(t);

         this.findPathAlg.run();

         FixedPath p = this.findPathAlg.getPathTo(t);

         assertNotNull(p);

         assertEquals(4, p.getNumNodes());

     }

 }