Changeset 774:4297098d9677 in lemon-0.x for src/test/graph_test.cc

Timestamp:

08/30/04 14:01:47 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1066

Message:

Merge back the whole branches/hugo++ to trunk.

File:

• src/test/graph_test.cc (modified) (14 diffs)

src/test/graph_test.cc

@@ -7 +7 @@
 #include"test_tools.h"
 
-/*
+/**
+\file
 This test makes consistency checks of list graph structures.
 
-G.addNode(), G.addEdge(), G.valid(), G.tail(), G.head()
+G.addNode(), G.addEdge(), G.tail(), G.head()
 
 \todo Checks for empty graphs and isolated points.
+\todo Checks for Node->NodeIt, Edge->{EdgeIt,InEdgeIt,OutEdgeIt}
+conversion.
 */
 
@@ -30 +33 @@
     Node i; Node j(i); Node k(INVALID);
     i=j;
-    bool b=G.valid(i); b=b;
+    //    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);
   }
@@ -37 +42 @@
     i=j;
     j=G.first(i);
-    j=G.next(i);
-    bool b=G.valid(i); b=b;
+    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=G.valid(i); b=b;
+    bool b; b=b;
+    b=(i==INVALID); b=(i!=INVALID);
     b=(i==j); b=(i!=j); b=(i<j);
   }
@@ -53 +64 @@
     i=j;
     j=G.first(i);
-    j=G.next(i);
-    bool b=G.valid(i); b=b;
+    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);
   }
   {
@@ -64 +79 @@
     i=j;
     j=G.first(i,n);
-    j=G.next(i);
-    bool b=G.valid(i); b=b;
+    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);
   }
   {
@@ -75 +94 @@
     i=j;
     j=G.first(i,n);
-    j=G.next(i);
-    bool b=G.valid(i); b=b;
+    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);
-  }
-
-  Node n,m;
-  n=m=INVALID;
-  Edge e;
-  e=INVALID;
-  n=G.tail(e);
-  n=G.head(e);
-
-  //aNode, bNode ?
-
+    //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
-  { int i=G.id(n); i=i; }
-  { int i=G.id(e); i=i; }
-  
-  //  G.clear();
-
+  { 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);
-    typename Graph::template NodeMap<int> const &cm = m;  //Const map
+    //Const map
+    typename Graph::template NodeMap<int> const &cm = m;
     //Inicialize with default value
     typename Graph::template NodeMap<int> mdef(G,12);
-    typename Graph::template NodeMap<int> mm(cm);   //Copy
-    typename Graph::template NodeMap<double> dm(cm); //Copy from another type
+    //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);
@@ -161 +182 @@
     m=dm; //Copy to another type
   }
-  
 }
 
@@ -178 +198 @@
   n=G.addNode();
   m=G.addNode();
-  
-  G.addEdge(n,m);
+  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()));  
 }
 
@@ -187 +235 @@
   typename Graph::NodeIt n(G);
   for(int i=0;i<nn;i++) {
-    check(G.valid(n),"Wrong Node list linking.");
-    G.next(n);
-  }
-  check(!G.valid(n),"Wrong Node list linking.");
+    check(n!=INVALID,"Wrong Node list linking.");
+    ++n;
+  }
+  check(n==INVALID,"Wrong Node list linking.");
 }
 
@@ -199 +247 @@
   EdgeIt e(G);
   for(int i=0;i<nn;i++) {
-    check(G.valid(e),"Wrong Edge list linking.");
-    G.next(e);
-  }
-  check(!G.valid(e),"Wrong Edge list linking.");
+    check(e!=INVALID,"Wrong Edge list linking.");
+    ++e;
+  }
+  check(e==INVALID,"Wrong Edge list linking.");
 }
 
@@ -211 +259 @@
   typename Graph::OutEdgeIt e(G,n);
   for(int i=0;i<nn;i++) {
-    check(G.valid(e),"Wrong OutEdge list linking.");
-    G.next(e);
-  }
-  check(!G.valid(e),"Wrong OutEdge list linking.");
+    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::Node n,
+                                           int nn)
 {
   typename Graph::InEdgeIt e(G,n);
   for(int i=0;i<nn;i++) {
-    check(G.valid(e),"Wrong InEdge list linking.");
-    G.next(e);
-  }
-  check(!G.valid(e),"Wrong InEdge list linking.");
-}
-
-//Checks head(), tail() as well;
+    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)
 {
@@ -239 +289 @@
   std::vector<Edge> ee;
   
-  for(EdgeIt e(G);G.valid(e);G.next(e)) ee.push_back(e);
+  for(EdgeIt e(G);e!=INVALID;++e) ee.push_back(e);
 
   for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)
@@ -255 +305 @@
   checkEdgeList(G,30);
 
-  for(NodeIt n(G);G.valid(n);G.next(n)) {
+  for(NodeIt n(G);n!=INVALID;++n) {
     checkInEdgeList(G,n,3);
     checkOutEdgeList(G,n,3);
-    G.next(n);
+    ++n;
   }  
 }
 
-template
+//Compile GraphSkeleton
+template 
 void checkCompileStaticGraph<StaticGraphSkeleton>(StaticGraphSkeleton &);
 template void checkCompile<GraphSkeleton>(GraphSkeleton &);
-
+template
+void checkCompileErase<EraseableGraphSkeleton>(EraseableGraphSkeleton &);
+
+//Compile SmartGraph
 template void checkCompile<SmartGraph>(SmartGraph &);
+//Compile SymSmartGraph
 template void checkCompile<SymSmartGraph>(SymSmartGraph &);
+
+//Compile ListGraph
 template void checkCompile<ListGraph>(ListGraph &);
+template void checkCompileErase<ListGraph>(ListGraph &);
+template void checkCompileFindEdge<ListGraph>(ListGraph &);
+
+//Compile SymListGraph
 template void checkCompile<SymListGraph>(SymListGraph &);
+template void checkCompileErase<SymListGraph>(SymListGraph &);
+template void checkCompileFindEdge<SymListGraph>(SymListGraph &);
+
+//Compile FullGraph
 template void checkCompileStaticGraph<FullGraph>(FullGraph &);
-
+template void checkCompileFindEdge<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> &);
+
+//Compile EdgeSet <NodeSet>
 template void checkCompile<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
+template
+void checkCompileEraseEdge<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
+template void checkCompileFindEdge<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
+
 
 int main() 
@@ -300 +377 @@
   }
 
-  //\todo map tests.
-  //\todo copy constr tests.
+  ///\file
+  ///\todo map tests.
+  ///\todo copy constr tests.
 
   std::cout << __FILE__ ": All tests passed.\n";