[Lemon-commits] [lemon_svn] alpar: r1094 - hugo/trunk/src/test
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:43:13 CET 2006
Author: alpar
Date: Fri Sep 3 19:34:22 2004
New Revision: 1094
Added:
hugo/trunk/src/test/graph_test.h
Modified:
hugo/trunk/src/test/Makefile.am
hugo/trunk/src/test/graph_test.cc
Log:
Move general graph compilation tests to 'src/test/graph_test.h'.
Modified: hugo/trunk/src/test/Makefile.am
==============================================================================
--- hugo/trunk/src/test/Makefile.am (original)
+++ hugo/trunk/src/test/Makefile.am Fri Sep 3 19:34:22 2004
@@ -1,6 +1,6 @@
AM_CPPFLAGS = -I$(top_srcdir)/src
-noinst_HEADERS = test_tools.h
+noinst_HEADERS = test_tools.h graph_test.h
check_PROGRAMS = test_tools_pass test_tools_fail \
graph_test \
Modified: hugo/trunk/src/test/graph_test.cc
==============================================================================
--- hugo/trunk/src/test/graph_test.cc (original)
+++ hugo/trunk/src/test/graph_test.cc Fri Sep 3 19:34:22 2004
@@ -5,6 +5,7 @@
#include<hugo/full_graph.h>
#include"test_tools.h"
+#include"graph_test.h"
/**
\file
@@ -13,306 +14,17 @@
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.
*/
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)
{
typedef typename Graph::Edge Edge;
typedef typename Graph::EdgeIt EdgeIt;
- checkEdgeList(G,15);
+ checkGraphEdgeList(G,15);
std::vector<Edge> ee;
@@ -329,12 +41,12 @@
typedef typename Graph::EdgeIt EdgeIt;
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;
}
}
@@ -343,44 +55,48 @@
template void checkCompileStaticGraph<skeleton::StaticGraphSkeleton>
(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> &);
int main()
Added: hugo/trunk/src/test/graph_test.h
==============================================================================
--- (empty file)
+++ hugo/trunk/src/test/graph_test.h Fri Sep 3 19:34:22 2004
@@ -0,0 +1,306 @@
+#ifndef HUGO_TEST_GRAPH_TEST_H
+#define HUGO_TEST_GRAPH_TEST_H
+
+
+#include "test_tools.h"
+
+//! \ingroup misc
+//! \file
+//! \brief Some utility to test graph classes.
+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 checkCompileGraph(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 checkCompileGraphEraseEdge(Graph &G)
+{
+ typename Graph::Edge e;
+ G.erase(e);
+}
+
+template<class Graph> void checkCompileGraphEraseNode(Graph &G)
+{
+ typename Graph::Node n;
+ G.erase(n);
+}
+
+template<class Graph> void checkCompileErasableGraph(Graph &G)
+{
+ checkCompileGraph(G);
+ checkCompileGraphEraseNode(G);
+ checkCompileGraphEraseEdge(G);
+}
+
+template<class Graph> void checkCompileGraphFindEdge(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 checkGraphNodeList(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 checkGraphEdgeList(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 checkGraphOutEdgeList(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 checkGraphInEdgeList(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 Check head(), tail() as well;
+
+
+} //namespace hugo
+
+
+#endif
More information about the Lemon-commits
mailing list