/*

     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 15.01.2005

  *

  */

 package net.sourceforge.combean.test.samples.simplegraphs;

 import java.util.BitSet;

 import junit.framework.TestCase;

 import net.sourceforge.combean.graph.NumberNode;

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

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

 import net.sourceforge.combean.samples.simplegraphs.Clique;

 import net.sourceforge.combean.samples.simplegraphs.CompositeNumberGraph;

 import net.sourceforge.combean.samples.simplegraphs.NumberGraph;

 import net.sourceforge.combean.samples.simplegraphs.Path;

 import net.sourceforge.combean.test.helpers.checks.CheckGraph;

 /**

  * @author schickin

  *

  */

 public class TestCompositeNumberGraph extends TestCase {

         private static final int PATHLEN = 5;

         private Path path;

         private static final int CLIQUESIZE = 5;

         private Clique clique;

         private NumberNode firstNode;

         private NumberNode lastPathNode;

         private CompositeNumberGraph lollypop;

         private CompositeNumberGraph mix;

         public static void main(String[] args) {

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

         }

         /*

          * @see TestCase#setUp()

          */

         protected void setUp() throws Exception {

                 super.setUp();

                 this.path = new Path(PATHLEN);

                 this.clique = new Clique(CLIQUESIZE);

                 this.firstNode = new NumberNode(0);

                 this.lastPathNode = new NumberNode(PATHLEN-1);

                 this.lollypop = new CompositeNumberGraph();

                 this.lollypop.add(this.path);

                 this.lollypop.add(this.clique, this.lastPathNode.getNodeNum());

                 this.mix = new CompositeNumberGraph();

                 this.mix.add(this.path);

                 this.mix.add(this.clique);

 }

         /*

          * @see TestCase#tearDown()

          */

         protected void tearDown() throws Exception {

                 super.tearDown();

         }

         public final void testGetNumGraphs() {

                 assertEquals("two graphs have been added", 2,

                                 this.lollypop.getNumGraphs());

                 assertEquals("two graphs have been added", 2,

                                 this.mix.getNumGraphs());

         }

         public final void testGetNumNodes() {

                 assertEquals("number of nodes in joined graphs must equal" +

                                 "the sum minus one overlapping node",

                                 PATHLEN+CLIQUESIZE-1, this.lollypop.getNumNodes());

                 assertEquals("number of nodes in joined graphs must equal" +

                                 "the maximum of nodes in the individual graphs",

                                 Math.max(PATHLEN, CLIQUESIZE), this.mix.getNumNodes());

         }

         public final void testGetAllNodesIterator() {

                 NodeIterator itAllNodes = this.lollypop.getAllNodesIterator();

                 BitSet nodesSeen = new BitSet(PATHLEN+CLIQUESIZE);

                 nodesSeen.clear();

                 while (itAllNodes.hasNext()) {

                         NumberNode currNode = (NumberNode) itAllNodes.next();

                         nodesSeen.set(currNode.getNodeNum());

                 }

                 assertEquals("all nodes must have been seen", PATHLEN+CLIQUESIZE-1,

                                 nodesSeen.nextClearBit(0));

         }

         public final void testGetIncidentEdges() {

                 EdgeIterator itNeigh = null;

                 itNeigh = this.lollypop.getIncidentEdges(this.firstNode);

                 CheckGraph.checkNumIterations(itNeigh, 1);

                 itNeigh = this.lollypop.getIncidentEdges(this.lastPathNode);

                 CheckGraph.checkNumIterations(itNeigh, CLIQUESIZE-1+1);

                 itNeigh = this.mix.getIncidentEdges(this.firstNode);

                 CheckGraph.checkNumIterations(itNeigh, CLIQUESIZE-1);

                 itNeigh = this.mix.getIncidentEdges(this.lastPathNode);

                 CheckGraph.checkNumIterations(itNeigh, CLIQUESIZE-1);

 }

         public final void testContains() {

                 assertTrue(this.lollypop.contains(new NumberNode(0)));

                 assertTrue(this.lollypop.contains(new NumberNode(PATHLEN+CLIQUESIZE-2)));

                 assertFalse(this.lollypop.contains(new NumberNode(PATHLEN+CLIQUESIZE-1)));

                 assertFalse(this.lollypop.contains(new NumberNode(NumberGraph.NOSUCHNODE)));

         }

 }