Index: src/test/graph_test.cc
===================================================================
--- src/test/graph_test.cc	(revision 793)
+++ src/test/graph_test.cc	(revision 800)
@@ -6,4 +6,5 @@
 
 #include"test_tools.h"
+#include"graph_test.h"
 
 /**
@@ -14,297 +15,8 @@
 
 \todo Checks for empty graphs and isolated points.
-\todo Checks for Node->NodeIt, Edge->{EdgeIt,InEdgeIt,OutEdgeIt}
 conversion.
 */
 
 using namespace hugo;
-
-template<class Graph> void checkCompileStaticGraph(Graph &G) 
-{
-  typedef typename Graph::Node Node;
-  typedef typename Graph::NodeIt NodeIt;
-  typedef typename Graph::Edge Edge;
-  typedef typename Graph::EdgeIt EdgeIt;
-  typedef typename Graph::InEdgeIt InEdgeIt;
-  typedef typename Graph::OutEdgeIt OutEdgeIt;
-  
-  {
-    Node i; Node j(i); Node k(INVALID);
-    i=j;
-    //    bool b=G.valid(i); b=b;
-    bool b; b=b;
-    b=(i==INVALID); b=(i!=INVALID);
-    b=(i==j); b=(i!=j); b=(i<j);
-  }
-  {
-    NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G);
-    i=j;
-    j=G.first(i);
-    j=++i;
-    //    bool b=G.valid(i); b=b;
-    bool b; b=b;
-    b=(i==INVALID); b=(i!=INVALID);
-    Node n(i);
-    n=i;
-    b=(i==j); b=(i!=j); b=(i<j);
-    //Node ->NodeIt conversion
-    NodeIt ni(G,n);
-  }
-  {
-    Edge i; Edge j(i); Edge k(INVALID);
-    i=j;
-    //    bool b=G.valid(i); b=b;
-    bool b; b=b;
-    b=(i==INVALID); b=(i!=INVALID);
-    b=(i==j); b=(i!=j); b=(i<j);
-  }
-  {
-    EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G);
-    i=j;
-    j=G.first(i);
-    j=++i;
-    //    bool b=G.valid(i); b=b;
-    bool b; b=b;
-    b=(i==INVALID); b=(i!=INVALID);
-    Edge e(i);
-    e=i;
-    b=(i==j); b=(i!=j); b=(i<j);
-    //Edge ->EdgeIt conversion
-    EdgeIt ei(G,e);
-  }
-  {
-    Node n;
-    InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n);
-    i=j;
-    j=G.first(i,n);
-    j=++i;
-    //    bool b=G.valid(i); b=b;
-    bool b; b=b;
-    b=(i==INVALID); b=(i!=INVALID);
-    Edge e(i);
-    e=i;
-    b=(i==j); b=(i!=j); b=(i<j);
-    //Edge ->InEdgeIt conversion
-    InEdgeIt ei(G,e);
-  }
-  {
-    Node n;
-    OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n);
-    i=j;
-    j=G.first(i,n);
-    j=++i;
-    //    bool b=G.valid(i); b=b;
-    bool b; b=b;
-    b=(i==INVALID); b=(i!=INVALID);
-    Edge e(i);
-    e=i;
-    b=(i==j); b=(i!=j); b=(i<j);
-    //Edge ->OutEdgeIt conversion
-    OutEdgeIt ei(G,e);
-  }
-  {
-    Node n,m;
-    n=m=INVALID;
-    Edge e;
-    e=INVALID;
-    n=G.tail(e);
-    n=G.head(e);
-  }
-  // id tests
-  { Node n; int i=G.id(n); i=i; }
-  { Edge e; int i=G.id(e); i=i; }
-  //NodeMap tests
-  {
-    Node k;
-    typename Graph::template NodeMap<int> m(G);
-    //Const map
-    typename Graph::template NodeMap<int> const &cm = m;
-    //Inicialize with default value
-    typename Graph::template NodeMap<int> mdef(G,12);
-    //Copy
-    typename Graph::template NodeMap<int> mm(cm);
-    //Copy from another type
-    typename Graph::template NodeMap<double> dm(cm);
-    int v;
-    v=m[k]; m[k]=v; m.set(k,v);
-    v=cm[k];
-    
-    m=cm;  
-    dm=cm; //Copy from another type
-    {
-      //Check the typedef's
-      typename Graph::template NodeMap<int>::ValueType val;
-      val=1;
-      typename Graph::template NodeMap<int>::KeyType key;
-      key = typename Graph::NodeIt(G);
-    }
-  }  
-  { //bool NodeMap
-    Node k;
-    typename Graph::template NodeMap<bool> m(G);
-    typename Graph::template NodeMap<bool> const &cm = m;  //Const map
-    //Inicialize with default value
-    typename Graph::template NodeMap<bool> mdef(G,12);
-    typename Graph::template NodeMap<bool> mm(cm);   //Copy
-    typename Graph::template NodeMap<int> dm(cm); //Copy from another type
-    bool v;
-    v=m[k]; m[k]=v; m.set(k,v);
-    v=cm[k];
-    
-    m=cm;  
-    dm=cm; //Copy from another type
-    m=dm; //Copy to another type
-
-    {
-      //Check the typedef's
-      typename Graph::template NodeMap<bool>::ValueType val;
-      val=true;
-      typename Graph::template NodeMap<bool>::KeyType key;
-      key= typename Graph::NodeIt(G);
-    }
-  }
-  //EdgeMap tests
-  {
-    Edge k;
-    typename Graph::template EdgeMap<int> m(G);
-    typename Graph::template EdgeMap<int> const &cm = m;  //Const map
-    //Inicialize with default value
-    typename Graph::template EdgeMap<int> mdef(G,12);
-    typename Graph::template EdgeMap<int> mm(cm);   //Copy
-    typename Graph::template EdgeMap<double> dm(cm); //Copy from another type
-    int v;
-    v=m[k]; m[k]=v; m.set(k,v);
-    v=cm[k];
-    
-    m=cm;  
-    dm=cm; //Copy from another type
-    {
-      //Check the typedef's
-      typename Graph::template EdgeMap<int>::ValueType val;
-      val=1;
-      typename Graph::template EdgeMap<int>::KeyType key;
-      key= typename Graph::EdgeIt(G);
-    }
-  }  
-  { //bool EdgeMap
-    Edge k;
-    typename Graph::template EdgeMap<bool> m(G);
-    typename Graph::template EdgeMap<bool> const &cm = m;  //Const map
-    //Inicialize with default value
-    typename Graph::template EdgeMap<bool> mdef(G,12);
-    typename Graph::template EdgeMap<bool> mm(cm);   //Copy
-    typename Graph::template EdgeMap<int> dm(cm); //Copy from another type
-    bool v;
-    v=m[k]; m[k]=v; m.set(k,v);
-    v=cm[k];
-    
-    m=cm;  
-    dm=cm; //Copy from another type
-    m=dm; //Copy to another type
-    {
-      //Check the typedef's
-      typename Graph::template EdgeMap<bool>::ValueType val;
-      val=true;
-      typename Graph::template EdgeMap<bool>::KeyType key;
-      key= typename Graph::EdgeIt(G);
-    }
-  }
-}
-
-template<class Graph> void checkCompile(Graph &G) 
-{
-  checkCompileStaticGraph(G);
-
-  typedef typename Graph::Node Node;
-  typedef typename Graph::NodeIt NodeIt;
-  typedef typename Graph::Edge Edge;
-  typedef typename Graph::EdgeIt EdgeIt;
-  typedef typename Graph::InEdgeIt InEdgeIt;
-  typedef typename Graph::OutEdgeIt OutEdgeIt;
-  
-  Node n,m;
-  n=G.addNode();
-  m=G.addNode();
-  Edge e;
-  e=G.addEdge(n,m); 
-  
-  //  G.clear();
-}
-
-template<class Graph> void checkCompileErase(Graph &G) 
-{
-  typedef typename Graph::Node Node;
-  typedef typename Graph::Edge Edge;
-  Node n;
-  Edge e;
-  G.erase(n);
-  G.erase(e);
-}
-
-template<class Graph> void checkCompileEraseEdge(Graph &G) 
-{
-  typedef typename Graph::Edge Edge;
-  Edge e;
-  G.erase(e);
-}
-
-template<class Graph> void checkCompileFindEdge(Graph &G) 
-{
-  typedef typename Graph::NodeIt Node;
-  typedef typename Graph::NodeIt NodeIt;
-
-  G.findEdge(NodeIt(G),++NodeIt(G),G.findEdge(NodeIt(G),++NodeIt(G)));
-  G.findEdge(Node(),Node(),G.findEdge(Node(),Node()));  
-}
-
-
-template<class Graph> void checkNodeList(Graph &G, int nn)
-{
-  typename Graph::NodeIt n(G);
-  for(int i=0;i<nn;i++) {
-    check(n!=INVALID,"Wrong Node list linking.");
-    ++n;
-  }
-  check(n==INVALID,"Wrong Node list linking.");
-}
-
-template<class Graph> void checkEdgeList(Graph &G, int nn)
-{
-  typedef typename Graph::EdgeIt EdgeIt;
-
-  EdgeIt e(G);
-  for(int i=0;i<nn;i++) {
-    check(e!=INVALID,"Wrong Edge list linking.");
-    ++e;
-  }
-  check(e==INVALID,"Wrong Edge list linking.");
-}
-
-template<class Graph> void checkOutEdgeList(Graph &G,
-					    typename Graph::Node n,
-					    int nn)
-{
-  typename Graph::OutEdgeIt e(G,n);
-  for(int i=0;i<nn;i++) {
-    check(e!=INVALID,"Wrong OutEdge list linking.");
-    ++e;
-  }
-  check(e==INVALID,"Wrong OutEdge list linking.");
-}
-
-template<class Graph> void checkInEdgeList(Graph &G,
-					   typename Graph::Node n,
-					   int nn)
-{
-  typename Graph::InEdgeIt e(G,n);
-  for(int i=0;i<nn;i++) {
-    check(e!=INVALID,"Wrong InEdge list linking.");
-    ++e;
-  }
-  check(e==INVALID,"Wrong InEdge list linking.");
-}
-
-///\file
-///\todo Checks head(), tail() as well;
 
 template<class Graph> void bidirPetersen(Graph &G)
@@ -313,5 +25,5 @@
   typedef typename Graph::EdgeIt EdgeIt;
   
-  checkEdgeList(G,15);
+  checkGraphEdgeList(G,15);
   
   std::vector<Edge> ee;
@@ -330,10 +42,10 @@
   typedef typename Graph::NodeIt NodeIt;
 
-  checkNodeList(G,10);
-  checkEdgeList(G,30);
+  checkGraphNodeList(G,10);
+  checkGraphEdgeList(G,30);
 
   for(NodeIt n(G);n!=INVALID;++n) {
-    checkInEdgeList(G,n,3);
-    checkOutEdgeList(G,n,3);
+    checkGraphInEdgeList(G,n,3);
+    checkGraphOutEdgeList(G,n,3);
     ++n;
   }  
@@ -344,42 +56,46 @@
 (skeleton::StaticGraphSkeleton &);
 
-template void checkCompile<skeleton::GraphSkeleton>(skeleton::GraphSkeleton &);
+template void checkCompileGraph<skeleton::GraphSkeleton>
+(skeleton::GraphSkeleton &);
 
-template void checkCompileErase<skeleton::EraseableGraphSkeleton>
+template void checkCompileErasableGraph<skeleton::EraseableGraphSkeleton>
 (skeleton::EraseableGraphSkeleton &);
 
 //Compile SmartGraph
-template void checkCompile<SmartGraph>(SmartGraph &);
+template void checkCompileGraph<SmartGraph>(SmartGraph &);
+template void checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
 
 //Compile SymSmartGraph
-template void checkCompile<SymSmartGraph>(SymSmartGraph &);
+template void checkCompileGraph<SymSmartGraph>(SymSmartGraph &);
+template void checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
 
 //Compile ListGraph
-template void checkCompile<ListGraph>(ListGraph &);
-template void checkCompileErase<ListGraph>(ListGraph &);
-template void checkCompileFindEdge<ListGraph>(ListGraph &);
+template void checkCompileGraph<ListGraph>(ListGraph &);
+template void checkCompileErasableGraph<ListGraph>(ListGraph &);
+template void checkCompileGraphFindEdge<ListGraph>(ListGraph &);
 
 
 //Compile SymListGraph
-template void checkCompile<SymListGraph>(SymListGraph &);
-template void checkCompileErase<SymListGraph>(SymListGraph &);
-template void checkCompileFindEdge<SymListGraph>(SymListGraph &);
+template void checkCompileGraph<SymListGraph>(SymListGraph &);
+template void checkCompileErasableGraph<SymListGraph>(SymListGraph &);
+template void checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
 
 //Compile FullGraph
 template void checkCompileStaticGraph<FullGraph>(FullGraph &);
-template void checkCompileFindEdge<FullGraph>(FullGraph &);
+template void checkCompileGraphFindEdge<FullGraph>(FullGraph &);
 
 //Compile EdgeSet <ListGraph>
-template void checkCompile<EdgeSet <ListGraph> >(EdgeSet <ListGraph> &);
-template
-void checkCompileEraseEdge<EdgeSet <ListGraph> >(EdgeSet <ListGraph> &);
-template
-void checkCompileFindEdge<EdgeSet <ListGraph> >(EdgeSet <ListGraph> &);
+template void checkCompileGraph<EdgeSet <ListGraph> >(EdgeSet <ListGraph> &);
+template void checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
+(EdgeSet <ListGraph> &);
+template void checkCompileGraphFindEdge<EdgeSet <ListGraph> >
+(EdgeSet <ListGraph> &);
 
 //Compile EdgeSet <NodeSet>
-template void checkCompile<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
-template
-void checkCompileEraseEdge<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
-template void checkCompileFindEdge<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
+template void checkCompileGraph<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
+template void checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
+(EdgeSet <NodeSet> &);
+template void checkCompileGraphFindEdge<EdgeSet <NodeSet> >
+(EdgeSet <NodeSet> &);
 
 
