lemon-0.x: src/test/graph_test.cc@26e1cd224bdc

     1 #include<iostream>

     2 #include<hugo/smart_graph.h>

     3 #include<hugo/skeletons/graph.h>

     4 #include<hugo/list_graph.h>

     6 #include"test_tools.h"

     8 /*

     9 This test makes consistency checks of list graph structures.

    11 G.addNode(), G.addEdge(), G.valid(), G.tail(), G.head()

    13 */

    15 using namespace hugo;

    17 template<class Graph> void checkCompile(Graph &G)

    18 {

    19   typedef typename Graph::Node Node;

    20   typedef typename Graph::NodeIt NodeIt;

    21   typedef typename Graph::Edge Edge;

    22   typedef typename Graph::EdgeIt EdgeIt;

    23   typedef typename Graph::InEdgeIt InEdgeIt;

    24   typedef typename Graph::OutEdgeIt OutEdgeIt;

    26   {

    27     Node i; Node j(i); Node k(INVALID);

    28     i=j;

    29     bool b=G.valid(i); b=b;

    30     b=(i==j); b=(i!=j); b=(i<j);

    31   }

    32   {

    33     NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G);

    34     i=j;

    35     j=G.first(i);

    36     j=G.next(i);

    37     bool b=G.valid(i); b=b;

    38     Node n(i);

    39     n=i;

    40     b=(i==j); b=(i!=j); b=(i<j);

    41   }

    42   {

    43     Edge i; Edge j(i); Edge k(INVALID);

    44     i=j;

    45     bool b=G.valid(i); b=b;

    46     b=(i==j); b=(i!=j); b=(i<j);

    47   }

    48   {

    49     EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G);

    50     i=j;

    51     j=G.first(i);

    52     j=G.next(i);

    53     bool b=G.valid(i); b=b;

    54     Edge e(i);

    55     e=i;

    56     b=(i==j); b=(i!=j); b=(i<j);

    57   }

    58   {

    59     Node n;

    60     InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n);

    61     i=j;

    62     j=G.first(i,n);

    63     j=G.next(i);

    64     bool b=G.valid(i); b=b;

    65     Edge e(i);

    66     e=i;

    67     b=(i==j); b=(i!=j); b=(i<j);

    68   }

    69   {

    70     Node n;

    71     OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n);

    72     i=j;

    73     j=G.first(i,n);

    74     j=G.next(i);

    75     bool b=G.valid(i); b=b;

    76     Edge e(i);

    77     e=i;

    78     b=(i==j); b=(i!=j); b=(i<j);

    79   }

    81   Node n,m;

    82   n=G.addNode();

    83   Edge e;

    84   e=G.addEdge(n,m);

    85   n=G.tail(e);

    86   n=G.head(e);

    88   //aNode, bNode ?

    90   // id tests

    91   { int i=G.id(n); i=i; }

    92   { int i=G.id(e); i=i; }

    94   G.clear();

    96   //NodeMap tests

    97   {

    98     Node k;

    99     typename Graph::template NodeMap<int> m(G);

   100     typename Graph::template NodeMap<int> const &cm = m;  //Const map

   101     //Inicialize with default value

   102     typename Graph::template NodeMap<int> mdef(G,12);

   103     typename Graph::template NodeMap<int> mm(cm);   //Copy

   104     typename Graph::template NodeMap<double> dm(cm); //Copy from another type

   105     int v;

   106     v=m[k]; m[k]=v; m.set(k,v);

   107     v=cm[k];

   109     m=cm;

   110     dm=cm; //Copy from another type

   111   }

   112   { //bool NodeMap

   113     Node k;

   114     typename Graph::template NodeMap<bool> m(G);

   115     typename Graph::template NodeMap<bool> const &cm = m;  //Const map

   116     //Inicialize with default value

   117     typename Graph::template NodeMap<bool> mdef(G,12);

   118     typename Graph::template NodeMap<bool> mm(cm);   //Copy

   119     typename Graph::template NodeMap<int> dm(cm); //Copy from another type

   120     bool v;

   121     v=m[k]; m[k]=v; m.set(k,v);

   122     v=cm[k];

   124     m=cm;

   125     dm=cm; //Copy from another type

   126     m=dm; //Copy to another type

   127   }

   128   //EdgeMap tests

   129   {

   130     Edge k;

   131     typename Graph::template EdgeMap<int> m(G);

   132     typename Graph::template EdgeMap<int> const &cm = m;  //Const map

   133     //Inicialize with default value

   134     typename Graph::template EdgeMap<int> mdef(G,12);

   135     typename Graph::template EdgeMap<int> mm(cm);   //Copy

   136     typename Graph::template EdgeMap<double> dm(cm); //Copy from another type

   137     int v;

   138     v=m[k]; m[k]=v; m.set(k,v);

   139     v=cm[k];

   141     m=cm;

   142     dm=cm; //Copy from another type

   143   }

   144   { //bool EdgeMap

   145     Edge k;

   146     typename Graph::template EdgeMap<bool> m(G);

   147     typename Graph::template EdgeMap<bool> const &cm = m;  //Const map

   148     //Inicialize with default value

   149     typename Graph::template EdgeMap<bool> mdef(G,12);

   150     typename Graph::template EdgeMap<bool> mm(cm);   //Copy

   151     typename Graph::template EdgeMap<int> dm(cm); //Copy from another type

   152     bool v;

   153     v=m[k]; m[k]=v; m.set(k,v);

   154     v=cm[k];

   156     m=cm;

   157     dm=cm; //Copy from another type

   158     m=dm; //Copy to another type

   159   }

   161 }

   163 template<class Graph> void checkNodeList(Graph &G, int nn)

   164 {

   165   typename Graph::NodeIt n(G);

   166   for(int i=0;i<nn;i++) {

   167     check(G.valid(n),"Wrong Node list linking.");

   168     G.next(n);

   169   }

   170   check(!G.valid(n),"Wrong Node list linking.");

   171 }

   173 template<class Graph> void checkEdgeList(Graph &G, int nn)

   174 {

   175   typedef typename Graph::EdgeIt EdgeIt;

   177   EdgeIt e(G);

   178   for(int i=0;i<nn;i++) {

   179     check(G.valid(e),"Wrong Edge list linking.");

   180     G.next(e);

   181   }

   182   check(!G.valid(e),"Wrong Edge list linking.");

   183 }

   185 template<class Graph> void checkOutEdgeList(Graph &G,

   186 					    typename Graph::Node n,

   187 					    int nn)

   188 {

   189   typename Graph::OutEdgeIt e(G,n);

   190   for(int i=0;i<nn;i++) {

   191     check(G.valid(e),"Wrong OutEdge list linking.");

   192     G.next(e);

   193   }

   194   check(!G.valid(e),"Wrong OutEdge list linking.");

   195 }

   197 template<class Graph> void checkInEdgeList(Graph &G,

   198 					    typename Graph::Node n,

   199 					    int nn)

   200 {

   201   typename Graph::InEdgeIt e(G,n);

   202   for(int i=0;i<nn;i++) {

   203     check(G.valid(e),"Wrong InEdge list linking.");

   204     G.next(e);

   205   }

   206   check(!G.valid(e),"Wrong InEdge list linking.");

   207 }

   209 //Checks head(), tail() as well;

   210 template<class Graph> void bidirPetersen(Graph &G)

   211 {

   212   typedef typename Graph::Edge Edge;

   213   typedef typename Graph::EdgeIt EdgeIt;

   215   checkEdgeList(G,15);

   217   std::vector<Edge> ee;

   219   for(EdgeIt e(G);G.valid(e);G.next(e)) ee.push_back(e);

   221   for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)

   222     G.addEdge(G.head(*p),G.tail(*p));

   223 }

   225 template<class Graph> void checkPetersen(Graph &G)

   226 {

   227   typedef typename Graph::Node Node;

   229   typedef typename Graph::EdgeIt EdgeIt;

   230   typedef typename Graph::NodeIt NodeIt;

   232   checkNodeList(G,10);

   233   checkEdgeList(G,30);

   235   for(NodeIt n(G);G.valid(n);G.next(n)) {

   236     checkInEdgeList(G,n,3);

   237     checkOutEdgeList(G,n,3);

   238     G.next(n);

   239   }

   240 }

   242 template void checkCompile<GraphSkeleton>(GraphSkeleton &);

   243 template void checkCompile<SmartGraph>(SmartGraph &);

   244 template void checkCompile<SymSmartGraph>(SymSmartGraph &);

   245 template void checkCompile<ListGraph>(ListGraph &);

   246 template void checkCompile<SymListGraph>(SymListGraph &);

   248 //Due to some mysterious problems it does not work.

   249 template void checkCompile<EdgeSet <ListGraph> >(EdgeSet <ListGraph> &);

   250 //template void checkCompile<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);

   252 int main()

   253 {

   254   {

   255     SmartGraph G;

   256     addPetersen(G);

   257     bidirPetersen(G);

   258     checkPetersen(G);

   259   }

   260   {

   261     ListGraph G;

   262     addPetersen(G);

   263     bidirPetersen(G);

   264     checkPetersen(G);

   265   }

   266   {

   267     SymSmartGraph G;

   268     addPetersen(G);

   269     checkPetersen(G);

   270   }

   271   {

   272     SymListGraph G;

   273     addPetersen(G);

   274     checkPetersen(G);

   275   }

   277   //\todo map tests.

   278   //\todo copy constr tests.

   280   std::cout << __FILE__ ": All tests passed.\n";

   282   return 0;

   283 }

author	jacint
	Fri, 07 May 2004 21:16:26 +0000
changeset 581	26e1cd224bdc
parent 578	159f1cbf8a45
child 592	5961cce7ec53
permissions	-rw-r--r--