COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #129: b6732e0d38c5.patch

File b6732e0d38c5.patch, 31.6 KB (added by Balazs Dezso, 16 years ago)

  • test/Makefile.am 

    # HG changeset patch
# User Balazs Dezso <deba@inf.elte.hu>
# Date 1216650628 -7200
# Node ID b6732e0d38c5c5e6b21123d8425a62591491e391
# Parent  33f8d69e642a7c456c127282bc420a2703fb14c1
Reworking graph testing

 - The graph tests check more graph functionality.
 - The petersen graph is too regular, therefore special graphs are used.
 - The graph_test.h contains just general tools to test graphs.

diff -r 33f8d69e642a -r b6732e0d38c5 test/Makefile.am
    a b  
    33
    44noinst_HEADERS += \
    55        test/graph_test.h \
    6         test/graph_maps_test.h \
    76        test/test_tools.h
    87
    98check_PROGRAMS += \

  • test/bfs_test.cc 

    diff -r 33f8d69e642a -r b6732e0d38c5 test/bfs_test.cc
    a b  
    1919#include <lemon/concepts/digraph.h>
    2020#include <lemon/smart_graph.h>
    2121#include <lemon/list_graph.h>
     22#include <lemon/lgf_reader.h>
    2223#include <lemon/bfs.h>
    2324#include <lemon/path.h>
    2425
    … …  
    2627#include "test_tools.h"
    2728
    2829using namespace lemon;
     30
     31char test_lgf[] =
     32  "@nodes\n"
     33  "label\n"
     34  "0\n"
     35  "1\n"
     36  "2\n"
     37  "3\n"
     38  "4\n"
     39  "5\n"
     40  "@arcs\n"
     41  "     label\n"
     42  "0 1  0\n"
     43  "1 2  1\n"
     44  "2 3  2\n"
     45  "3 4  3\n"
     46  "0 3  4\n"
     47  "0 3  5\n"
     48  "5 2  6\n"
     49  "@attributes\n"
     50  "source 0\n"
     51  "target 4\n";
    2952
    3053void checkBfsCompile()
    3154{
    … …  
    4972  e  = bfs_test.predArc(n);
    5073  n  = bfs_test.predNode(n);
    5174  d  = bfs_test.distMap();
     75
    5276  p  = bfs_test.predMap();
    5377  //  pn = bfs_test.predNodeMap();
    5478  b  = bfs_test.reached(n);
    … …  
    80104
    81105  Digraph G;
    82106  Node s, t;
    83   PetStruct<Digraph> ps = addPetersen(G, 5);
    84107
    85   s=ps.outer[2];
    86   t=ps.inner[0];
     108  std::istringstream input(test_lgf);
     109  digraphReader(input, G).
     110    node("source", s).
     111    node("target", t).
     112    run();
    87113
    88114  Bfs<Digraph> bfs_test(G);
    89115  bfs_test.run(s);
    90116
    91   check(bfs_test.dist(t)==3,"Bfs found a wrong path." << bfs_test.dist(t));
     117  check(bfs_test.dist(t)==2,"Bfs found a wrong path." << bfs_test.dist(t));
    92118
    93119  Path<Digraph> p = bfs_test.path(t);
    94   check(p.length()==3,"path() found a wrong path.");
     120  check(p.length()==2,"path() found a wrong path.");
    95121  check(checkPath(G, p),"path() found a wrong path.");
    96122  check(pathSource(G, p) == s,"path() found a wrong path.");
    97123  check(pathTarget(G, p) == t,"path() found a wrong path.");
    98124
    99125
    100   for(ArcIt e(G); e!=INVALID; ++e) {
    101     Node u=G.source(e);
    102     Node v=G.target(e);
     126  for(ArcIt a(G); a!=INVALID; ++a) {
     127    Node u=G.source(a);
     128    Node v=G.target(a);
    103129    check( !bfs_test.reached(u) ||
    104130           (bfs_test.dist(v) <= bfs_test.dist(u)+1),
    105            "Wrong output.");
     131           "Wrong output." << G.id(v) << ' ' << G.id(u));
    106132  }
    107133
    108134  for(NodeIt v(G); v!=INVALID; ++v) {
    109     check(bfs_test.reached(v),"Each node should be reached.");
    110     if ( bfs_test.predArc(v)!=INVALID ) {
    111       Arc e=bfs_test.predArc(v);
    112       Node u=G.source(e);
    113       check(u==bfs_test.predNode(v),"Wrong tree.");
    114       check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
    115             "Wrong distance. Difference: "
    116             << std::abs(bfs_test.dist(v) - bfs_test.dist(u)
    117                         - 1));
     135    if (bfs_test.reached(v)) {
     136      check(v==s || bfs_test.predArc(v)!=INVALID, "Wrong tree.");
     137      if (bfs_test.predArc(v)!=INVALID ) {
     138        Arc a=bfs_test.predArc(v);
     139        Node u=G.source(a);
     140        check(u==bfs_test.predNode(v),"Wrong tree.");
     141        check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
     142              "Wrong distance. Difference: "
     143              << std::abs(bfs_test.dist(v) - bfs_test.dist(u)
     144                          - 1));
     145      }
    118146    }
    119147  }
    120148}

  • test/dfs_test.cc 

    diff -r 33f8d69e642a -r b6732e0d38c5 test/dfs_test.cc
    a b  
    1919#include <lemon/concepts/digraph.h>
    2020#include <lemon/smart_graph.h>
    2121#include <lemon/list_graph.h>
     22#include <lemon/lgf_reader.h>
     23
    2224#include <lemon/dfs.h>
    2325#include <lemon/path.h>
    2426
    … …  
    2628#include "test_tools.h"
    2729
    2830using namespace lemon;
     31
     32char test_lgf[] =
     33  "@nodes\n"
     34  "label\n"
     35  "0\n"
     36  "1\n"
     37  "2\n"
     38  "3\n"
     39  "4\n"
     40  "5\n"
     41  "6\n"
     42  "@arcs\n"
     43  "     label\n"
     44  "0 1  0\n"
     45  "1 2  1\n"
     46  "2 3  2\n"
     47  "1 4  3\n"
     48  "4 2  4\n"
     49  "4 5  5\n"
     50  "5 0  6\n"
     51  "6 3  7\n"
     52  "@attributes\n"
     53  "source 0\n"
     54  "target 5\n";
    2955
    3056void checkDfsCompile()
    3157{
    … …  
    3965  bool b;
    4066  DType::DistMap d(G);
    4167  DType::PredMap p(G);
    42   //  DType::PredNodeMap pn(G);
    4368
    4469  DType dfs_test(G);
    4570
    … …  
    5075  n  = dfs_test.predNode(n);
    5176  d  = dfs_test.distMap();
    5277  p  = dfs_test.predMap();
    53   //  pn = dfs_test.predNodeMap();
    5478  b  = dfs_test.reached(n);
    5579
    5680  Path<Digraph> pp = dfs_test.path(n);
    … …  
    80104
    81105  Digraph G;
    82106  Node s, t;
    83   PetStruct<Digraph> ps = addPetersen(G, 5);
    84107
    85   s=ps.outer[2];
    86   t=ps.inner[0];
     108  std::istringstream input(test_lgf);
     109  digraphReader(input, G).
     110    node("source", s).
     111    node("target", t).
     112    run();
    87113
    88114  Dfs<Digraph> dfs_test(G);
    89115  dfs_test.run(s);
    … …  
    95121  check(pathTarget(G, p) == t,"path() found a wrong path.");
    96122
    97123  for(NodeIt v(G); v!=INVALID; ++v) {
    98     check(dfs_test.reached(v),"Each node should be reached.");
    99     if ( dfs_test.predArc(v)!=INVALID ) {
    100       Arc e=dfs_test.predArc(v);
    101       Node u=G.source(e);
    102       check(u==dfs_test.predNode(v),"Wrong tree.");
    103       check(dfs_test.dist(v) - dfs_test.dist(u) == 1,
    104             "Wrong distance. (" << dfs_test.dist(u) << "->"
    105             <<dfs_test.dist(v) << ')');
     124    if (dfs_test.reached(v)) {
     125      check(v==s || dfs_test.predArc(v)!=INVALID, "Wrong tree.");
     126      if (dfs_test.predArc(v)!=INVALID ) {
     127        Arc e=dfs_test.predArc(v);
     128        Node u=G.source(e);
     129        check(u==dfs_test.predNode(v),"Wrong tree.");
     130        check(dfs_test.dist(v) - dfs_test.dist(u) == 1,
     131              "Wrong distance. (" << dfs_test.dist(u) << "->"
     132              <<dfs_test.dist(v) << ')');
     133      }
    106134    }
    107135  }
    108136}

  • test/digraph_test.cc 

    diff -r 33f8d69e642a -r b6732e0d38c5 test/digraph_test.cc
    a b  
    2424
    2525#include "test_tools.h"
    2626#include "graph_test.h"
    27 #include "graph_maps_test.h"
    2827
    2928using namespace lemon;
    3029using namespace lemon::concepts;
    3130
    32 void check_concepts() {
     31template <class Digraph>
     32void checkDigraph() {
     33  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     34  Digraph G;
     35
     36  checkGraphNodeList(G, 0);
     37  checkGraphArcList(G, 0);
     38
     39  Node
     40    n1 = G.addNode(),
     41    n2 = G.addNode(),
     42    n3 = G.addNode();
     43  checkGraphNodeList(G, 3);
     44  checkGraphArcList(G, 0);
     45
     46  Arc a1 = G.addArc(n1, n2);
     47  check(G.source(a1) == n1 && G.target(a1) == n2, "Wrong arc");
     48  checkGraphNodeList(G, 3);
     49  checkGraphArcList(G, 1);
     50
     51  checkGraphOutArcList(G, n1, 1);
     52  checkGraphOutArcList(G, n2, 0);
     53  checkGraphOutArcList(G, n3, 0);
     54
     55  checkGraphInArcList(G, n1, 0);
     56  checkGraphInArcList(G, n2, 1);
     57  checkGraphInArcList(G, n3, 0);
     58
     59  checkGraphConArcList(G, 1);
     60
     61  Arc a2 = G.addArc(n2, n1), a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
     62  checkGraphNodeList(G, 3);
     63  checkGraphArcList(G, 4);
     64
     65  checkGraphOutArcList(G, n1, 1);
     66  checkGraphOutArcList(G, n2, 3);
     67  checkGraphOutArcList(G, n3, 0);
     68
     69  checkGraphInArcList(G, n1, 1);
     70  checkGraphInArcList(G, n2, 1);
     71  checkGraphInArcList(G, n3, 2);
     72
     73  checkGraphConArcList(G, 4);
     74
     75  checkNodeIds(G);
     76  checkArcIds(G);
     77  checkGraphNodeMap(G);
     78  checkGraphArcMap(G);
     79
     80}
     81
     82
     83void checkConcepts() {
    3384  { // Checking digraph components
    3485    checkConcept<BaseDigraphComponent, BaseDigraphComponent >();
    3586
    … …  
    51102    checkConcept<ExtendableDigraphComponent<>, ListDigraph>();
    52103    checkConcept<ClearableDigraphComponent<>, ListDigraph>();
    53104    checkConcept<ErasableDigraphComponent<>, ListDigraph>();
    54     checkDigraphIterators<ListDigraph>();
    55105  }
    56106  { // Checking SmartDigraph
    57107    checkConcept<Digraph, SmartDigraph>();
    58108    checkConcept<AlterableDigraphComponent<>, SmartDigraph>();
    59109    checkConcept<ExtendableDigraphComponent<>, SmartDigraph>();
    60110    checkConcept<ClearableDigraphComponent<>, SmartDigraph>();
    61     checkDigraphIterators<SmartDigraph>();
    62111  }
    63112//  { // Checking FullDigraph
    64113//    checkConcept<Digraph, FullDigraph>();
    65 //    checkDigraphIterators<FullDigraph>();
    66114//  }
    67115//  { // Checking HyperCubeDigraph
    68116//    checkConcept<Digraph, HyperCubeDigraph>();
    69 //    checkDigraphIterators<HyperCubeDigraph>();
    70117//  }
    71118}
    72119
    73120template <typename Digraph>
    74 void check_graph_validity() {
     121void checkDigraphValidity() {
    75122  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
    76123  Digraph g;
    77124
    … …  
    92139}
    93140
    94141template <typename Digraph>
    95 void check_graph_validity_erase() {
     142void checkDigraphValidityErase() {
    96143  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
    97144  Digraph g;
    98145
    … …  
    120167  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");
    121168}
    122169
    123 void check_digraphs() {
     170void checkDigraphs() {
    124171  { // Checking ListDigraph
    125172    checkDigraph<ListDigraph>();
    126     checkGraphNodeMap<ListDigraph>();
    127     checkGraphArcMap<ListDigraph>();
    128 
    129     check_graph_validity_erase<ListDigraph>();
     173    checkDigraphValidityErase<ListDigraph>();
    130174  }
    131175  { // Checking SmartDigraph
    132176    checkDigraph<SmartDigraph>();
    133     checkGraphNodeMap<SmartDigraph>();
    134     checkGraphArcMap<SmartDigraph>();
    135 
    136     check_graph_validity<SmartDigraph>();
     177    checkDigraphValidity<SmartDigraph>();
    137178  }
    138179}
    139180
    140181int main() {
    141   check_concepts();
    142   check_digraphs();
     182  checkDigraphs();
     183  checkConcepts();
    143184  return 0;
    144185}

  • test/dijkstra_test.cc 

    diff -r 33f8d69e642a -r b6732e0d38c5 test/dijkstra_test.cc
    a b  
    1919#include <lemon/concepts/digraph.h>
    2020#include <lemon/smart_graph.h>
    2121#include <lemon/list_graph.h>
     22#include <lemon/lgf_reader.h>
     23
    2224#include <lemon/dijkstra.h>
    2325#include <lemon/path.h>
    2426
    … …  
    2628#include "test_tools.h"
    2729
    2830using namespace lemon;
     31
     32char test_lgf[] =
     33  "@nodes\n"
     34  "label\n"
     35  "0\n"
     36  "1\n"
     37  "2\n"
     38  "3\n"
     39  "4\n"
     40  "@arcs\n"
     41  "     label length\n"
     42  "0 1  0     1\n"
     43  "1 2  1     1\n"
     44  "2 3  2     1\n"
     45  "0 3  4     5\n"
     46  "0 3  5     10\n"
     47  "0 3  6     7\n"
     48  "4 2  7     1\n"
     49  "@attributes\n"
     50  "source 0\n"
     51  "target 3\n";
    2952
    3053void checkDijkstraCompile()
    3154{
    … …  
    84107  Digraph G;
    85108  Node s, t;
    86109  LengthMap length(G);
    87   PetStruct<Digraph> ps = addPetersen(G, 5);
    88110
    89   for(int i=0;i<5;i++) {
    90     length[ps.outcir[i]]=4;
    91     length[ps.incir[i]]=1;
    92     length[ps.chords[i]]=10;
    93   }
    94   s=ps.outer[0];
    95   t=ps.inner[1];
     111  std::istringstream input(test_lgf);
     112  digraphReader(input, G).
     113    arcMap("length", length).
     114    node("source", s).
     115    node("target", t).
     116    run();
    96117
    97118  Dijkstra<Digraph, LengthMap>
    98119        dijkstra_test(G, length);
    99120  dijkstra_test.run(s);
    100121
    101   check(dijkstra_test.dist(t)==13,"Dijkstra found a wrong path.");
     122  check(dijkstra_test.dist(t)==3,"Dijkstra found a wrong path.");
    102123
    103124  Path<Digraph> p = dijkstra_test.path(t);
    104   check(p.length()==4,"getPath() found a wrong path.");
     125  check(p.length()==3,"getPath() found a wrong path.");
    105126  check(checkPath(G, p),"path() found a wrong path.");
    106127  check(pathSource(G, p) == s,"path() found a wrong path.");
    107128  check(pathTarget(G, p) == t,"path() found a wrong path.");
    … …  
    115136           dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]);
    116137  }
    117138
    118   for(NodeIt v(G); v!=INVALID; ++v){
    119     check(dijkstra_test.reached(v),"Each node should be reached.");
    120     if ( dijkstra_test.predArc(v)!=INVALID ) {
    121       Arc e=dijkstra_test.predArc(v);
    122       Node u=G.source(e);
    123       check(u==dijkstra_test.predNode(v),"Wrong tree.");
    124       check(dijkstra_test.dist(v) - dijkstra_test.dist(u) == length[e],
    125             "Wrong distance! Difference: " <<
    126             std::abs(dijkstra_test.dist(v)-dijkstra_test.dist(u)-length[e]));
     139  for(NodeIt v(G); v!=INVALID; ++v) {
     140    if (dijkstra_test.reached(v)) {
     141      check(v==s || dijkstra_test.predArc(v)!=INVALID, "Wrong tree.");
     142      if (dijkstra_test.predArc(v)!=INVALID ) {
     143        Arc e=dijkstra_test.predArc(v);
     144        Node u=G.source(e);
     145        check(u==dijkstra_test.predNode(v),"Wrong tree.");
     146        check(dijkstra_test.dist(v) - dijkstra_test.dist(u) == length[e],
     147              "Wrong distance! Difference: " <<
     148              std::abs(dijkstra_test.dist(v)-dijkstra_test.dist(u)-length[e]));
     149      }
    127150    }
    128151  }
    129152

  • deleted file test/graph_maps_test.h 

    diff -r 33f8d69e642a -r b6732e0d38c5 test/graph_maps_test.h
    + -  
    1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
    2  *
    3  * This file is a part of LEMON, a generic C++ optimization library.
    4  *
    5  * Copyright (C) 2003-2008
    6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
    8  *
    9  * Permission to use, modify and distribute this software is granted
    10  * provided that this copyright notice appears in all copies. For
    11  * precise terms see the accompanying LICENSE file.
    12  *
    13  * This software is provided "AS IS" with no warranty of any kind,
    14  * express or implied, and with no claim as to its suitability for any
    15  * purpose.
    16  *
    17  */
    18 
    19 #ifndef LEMON_TEST_MAP_TEST_H
    20 #define LEMON_TEST_MAP_TEST_H
    21 
    22 #include <vector>
    23 #include <lemon/maps.h>
    24 
    25 #include "test_tools.h"
    26 
    27 namespace lemon {
    28 
    29   template <typename Graph>
    30   void checkGraphNodeMap() {
    31     Graph graph;
    32     const int num = 16;
    33 
    34     typedef typename Graph::Node Node;
    35 
    36     std::vector<Node> nodes;
    37     for (int i = 0; i < num; ++i) {
    38       nodes.push_back(graph.addNode());
    39     }
    40     typedef typename Graph::template NodeMap<int> IntNodeMap;
    41     IntNodeMap map(graph, 42);
    42     for (int i = 0; i < int(nodes.size()); ++i) {
    43       check(map[nodes[i]] == 42, "Wrong map constructor.");
    44     }
    45     for (int i = 0; i < num; ++i) {
    46       nodes.push_back(graph.addNode());
    47       map[nodes.back()] = 23;
    48       check(map[nodes.back()] == 23, "Wrong operator[].");
    49     }
    50     map = constMap<Node>(12);
    51     for (int i = 0; i < int(nodes.size()); ++i) {
    52       check(map[nodes[i]] == 12, "Wrong map constructor.");
    53     }
    54     graph.clear();
    55     nodes.clear();
    56   }
    57 
    58   template <typename Graph>
    59   void checkGraphArcMap() {
    60     Graph graph;
    61     const int num = 16;
    62 
    63     typedef typename Graph::Node Node;
    64     typedef typename Graph::Arc Arc;
    65 
    66     std::vector<Node> nodes;
    67     for (int i = 0; i < num; ++i) {
    68       nodes.push_back(graph.addNode());
    69     }
    70 
    71     std::vector<Arc> arcs;
    72     for (int i = 0; i < num; ++i) {
    73       for (int j = 0; j < i; ++j) {
    74         arcs.push_back(graph.addArc(nodes[i], nodes[j]));
    75       }
    76     }
    77 
    78     typedef typename Graph::template ArcMap<int> IntArcMap;
    79     IntArcMap map(graph, 42);
    80 
    81     for (int i = 0; i < int(arcs.size()); ++i) {
    82       check(map[arcs[i]] == 42, "Wrong map constructor.");
    83     }
    84 
    85     for (int i = 0; i < num; ++i) {
    86       for (int j = i + 1; j < num; ++j) {
    87         arcs.push_back(graph.addArc(nodes[i], nodes[j]));
    88         map[arcs.back()] = 23;
    89         check(map[arcs.back()] == 23, "Wrong operator[].");
    90       }
    91     }
    92     map = constMap<Arc>(12);
    93     for (int i = 0; i < int(arcs.size()); ++i) {
    94       check(map[arcs[i]] == 12, "Wrong map constructor.");
    95     }
    96     graph.clear();
    97     arcs.clear();
    98   }
    99 
    100   template <typename Graph>
    101   void checkGraphEdgeMap() {
    102     Graph graph;
    103     const int num = 16;
    104 
    105     typedef typename Graph::Node Node;
    106     typedef typename Graph::Edge Edge;
    107 
    108     std::vector<Node> nodes;
    109     for (int i = 0; i < num; ++i) {
    110       nodes.push_back(graph.addNode());
    111     }
    112 
    113     std::vector<Edge> edges;
    114     for (int i = 0; i < num; ++i) {
    115       for (int j = 0; j < i; ++j) {
    116         edges.push_back(graph.addEdge(nodes[i], nodes[j]));
    117       }
    118     }
    119 
    120     typedef typename Graph::template EdgeMap<int> IntEdgeMap;
    121     IntEdgeMap map(graph, 42);
    122 
    123     for (int i = 0; i < int(edges.size()); ++i) {
    124       check(map[edges[i]] == 42, "Wrong map constructor.");
    125     }
    126 
    127     for (int i = 0; i < num; ++i) {
    128       for (int j = i + 1; j < num; ++j) {
    129         edges.push_back(graph.addEdge(nodes[i], nodes[j]));
    130         map[edges.back()] = 23;
    131         check(map[edges.back()] == 23, "Wrong operator[].");
    132       }
    133     }
    134     map = constMap<Edge>(12);
    135     for (int i = 0; i < int(edges.size()); ++i) {
    136       check(map[edges[i]] == 12, "Wrong map constructor.");
    137     }
    138     graph.clear();
    139     edges.clear();
    140   }
    141 
    142 }
    143 
    144 #endif

  • test/graph_test.cc 

    diff -r 33f8d69e642a -r b6732e0d38c5 test/graph_test.cc
    a b  
    2424
    2525#include "test_tools.h"
    2626#include "graph_test.h"
    27 #include "graph_maps_test.h"
    2827
    2928using namespace lemon;
    3029using namespace lemon::concepts;
    3130
    32 void check_concepts() {
     31template <class Graph>
     32void checkGraph() {
     33  TEMPLATE_GRAPH_TYPEDEFS(Graph);
     34
     35  Graph G;
     36  checkGraphNodeList(G, 0);
     37  checkGraphEdgeList(G, 0);
     38
     39  Node
     40    n1 = G.addNode(),
     41    n2 = G.addNode(),
     42    n3 = G.addNode();
     43  checkGraphNodeList(G, 3);
     44  checkGraphEdgeList(G, 0);
     45
     46  Edge e1 = G.addEdge(n1, n2);
     47  check((G.u(e1) == n1 && G.v(e1) == n2) || (G.u(e1) == n2 && G.v(e1) == n1),
     48        "Wrong edge");
     49  checkGraphNodeList(G, 3);
     50  checkGraphArcList(G, 2);
     51  checkGraphEdgeList(G, 1);
     52
     53  checkGraphOutArcList(G, n1, 1);
     54  checkGraphOutArcList(G, n2, 1);
     55  checkGraphOutArcList(G, n3, 0);
     56
     57  checkGraphInArcList(G, n1, 1);
     58  checkGraphInArcList(G, n2, 1);
     59  checkGraphInArcList(G, n3, 0);
     60
     61  checkGraphIncEdgeList(G, n1, 1);
     62  checkGraphIncEdgeList(G, n2, 1);
     63  checkGraphIncEdgeList(G, n3, 0);
     64
     65  checkGraphConArcList(G, 2);
     66  checkGraphConEdgeList(G, 1);
     67
     68  Edge e2 = G.addEdge(n2, n1), e3 = G.addEdge(n2, n3);
     69  checkGraphNodeList(G, 3);
     70  checkGraphArcList(G, 6);
     71  checkGraphEdgeList(G, 3);
     72
     73  checkGraphOutArcList(G, n1, 2);
     74  checkGraphOutArcList(G, n2, 3);
     75  checkGraphOutArcList(G, n3, 1);
     76
     77  checkGraphInArcList(G, n1, 2);
     78  checkGraphInArcList(G, n2, 3);
     79  checkGraphInArcList(G, n3, 1);
     80
     81  checkGraphIncEdgeList(G, n1, 2);
     82  checkGraphIncEdgeList(G, n2, 3);
     83  checkGraphIncEdgeList(G, n3, 1);
     84
     85  checkGraphConArcList(G, 6);
     86  checkGraphConEdgeList(G, 3);
     87
     88  checkArcDirections(G);
     89
     90  checkNodeIds(G);
     91  checkArcIds(G);
     92  checkEdgeIds(G);
     93  checkGraphNodeMap(G);
     94  checkGraphArcMap(G);
     95  checkGraphEdgeMap(G);
     96}
     97
     98void checkConcepts() {
    3399  { // Checking graph components
    34100    checkConcept<BaseGraphComponent, BaseGraphComponent >();
    35101
    … …  
    51117    checkConcept<ExtendableGraphComponent<>, ListGraph>();
    52118    checkConcept<ClearableGraphComponent<>, ListGraph>();
    53119    checkConcept<ErasableGraphComponent<>, ListGraph>();
    54     checkGraphIterators<ListGraph>();
    55120  }
    56121  { // Checking SmartGraph
    57122    checkConcept<Graph, SmartGraph>();
    58123    checkConcept<AlterableGraphComponent<>, SmartGraph>();
    59124    checkConcept<ExtendableGraphComponent<>, SmartGraph>();
    60125    checkConcept<ClearableGraphComponent<>, SmartGraph>();
    61     checkGraphIterators<SmartGraph>();
    62126  }
    63127//  { // Checking FullGraph
    64128//    checkConcept<Graph, FullGraph>();
    … …  
    71135}
    72136
    73137template <typename Graph>
    74 void check_graph_validity() {
     138void checkGraphValidity() {
    75139  TEMPLATE_GRAPH_TYPEDEFS(Graph);
    76140  Graph g;
    77141
    … …  
    94158}
    95159
    96160template <typename Graph>
    97 void check_graph_validity_erase() {
     161void checkGraphValidityErase() {
    98162  TEMPLATE_GRAPH_TYPEDEFS(Graph);
    99163  Graph g;
    100164
    … …  
    168232//   }
    169233// }
    170234
    171 void check_graphs() {
     235void checkGraphs() {
    172236  { // Checking ListGraph
    173237    checkGraph<ListGraph>();
    174     checkGraphNodeMap<ListGraph>();
    175     checkGraphEdgeMap<ListGraph>();
    176 
    177     check_graph_validity_erase<ListGraph>();
     238    checkGraphValidityErase<ListGraph>();
    178239  }
    179240  { // Checking SmartGraph
    180241    checkGraph<SmartGraph>();
    181     checkGraphNodeMap<SmartGraph>();
    182     checkGraphEdgeMap<SmartGraph>();
    183 
    184     check_graph_validity<SmartGraph>();
     242    checkGraphValidity<SmartGraph>();
    185243  }
    186244//   { // Checking FullGraph
    187245//     FullGraph g(5);
    … …  
    197255}
    198256
    199257int main() {
    200   check_concepts();
    201   check_graphs();
     258  checkConcepts();
     259  checkGraphs();
    202260  return 0;
    203261}

  • test/graph_test.h 

    diff -r 33f8d69e642a -r b6732e0d38c5 test/graph_test.h
    a b  
    1919#ifndef LEMON_TEST_GRAPH_TEST_H
    2020#define LEMON_TEST_GRAPH_TEST_H
    2121
     22#include <set>
     23
    2224#include <lemon/core.h>
     25#include <lemon/maps.h>
     26
    2327#include "test_tools.h"
    2428
    2529namespace lemon {
    … …  
    4246    typename Graph::ArcIt e(G);
    4347    for(int i=0;i<cnt;i++) {
    4448      check(e!=INVALID,"Wrong Arc list linking.");
     49      check(G.oppositeNode(G.source(e), e) == G.target(e),
     50            "Wrong opposite node");
     51      check(G.oppositeNode(G.target(e), e) == G.source(e),
     52            "Wrong opposite node");
    4553      ++e;
    4654    }
    4755    check(e==INVALID,"Wrong Arc list linking.");
    … …  
    5563    for(int i=0;i<cnt;i++) {
    5664      check(e!=INVALID,"Wrong OutArc list linking.");
    5765      check(n==G.source(e),"Wrong OutArc list linking.");
     66      check(n==G.baseNode(e),"Wrong OutArc list linking.");
     67      check(G.target(e)==G.runningNode(e),"Wrong OutArc list linking.");
    5868      ++e;
    5969    }
    6070    check(e==INVALID,"Wrong OutArc list linking.");
    … …  
    6878    for(int i=0;i<cnt;i++) {
    6979      check(e!=INVALID,"Wrong InArc list linking.");
    7080      check(n==G.target(e),"Wrong InArc list linking.");
     81      check(n==G.baseNode(e),"Wrong OutArc list linking.");
     82      check(G.source(e)==G.runningNode(e),"Wrong OutArc list linking.");
    7183      ++e;
    7284    }
    7385    check(e==INVALID,"Wrong InArc list linking.");
    … …  
    8092    typename Graph::EdgeIt e(G);
    8193    for(int i=0;i<cnt;i++) {
    8294      check(e!=INVALID,"Wrong Edge list linking.");
     95      check(G.oppositeNode(G.u(e), e) == G.v(e), "Wrong opposite node");
     96      check(G.oppositeNode(G.v(e), e) == G.u(e), "Wrong opposite node");
    8397      ++e;
    8498    }
    8599    check(e==INVALID,"Wrong Edge list linking.");
    … …  
    93107    for(int i=0;i<cnt;i++) {
    94108      check(e!=INVALID,"Wrong IncEdge list linking.");
    95109      check(n==G.u(e) || n==G.v(e),"Wrong IncEdge list linking.");
     110      check(n==G.baseNode(e),"Wrong OutArc list linking.");
     111      check(G.u(e)==G.runningNode(e) || G.v(e)==G.runningNode(e),
     112            "Wrong OutArc list linking.");
    96113      ++e;
    97114    }
    98115    check(e==INVALID,"Wrong IncEdge list linking.");
    99116    check(countIncEdges(G,n)==cnt,"Wrong IncEdge number.");
    100117  }
    101118
    102   template <class Digraph>
    103   void checkDigraphIterators() {
    104     typedef typename Digraph::Node Node;
    105     typedef typename Digraph::NodeIt NodeIt;
    106     typedef typename Digraph::Arc Arc;
    107     typedef typename Digraph::ArcIt ArcIt;
    108     typedef typename Digraph::InArcIt InArcIt;
    109     typedef typename Digraph::OutArcIt OutArcIt;
     119  template <class Graph>
     120  void checkGraphConArcList(const Graph &G, int cnt) {
     121    int i = 0;
     122    for (typename Graph::NodeIt u(G); u != INVALID; ++u) {
     123      for (typename Graph::NodeIt v(G); v != INVALID; ++v) {
     124        for (ConArcIt<Graph> a(G, u, v); a != INVALID; ++a) {
     125          check(G.source(a) == u, "Wrong iterator.");
     126          check(G.target(a) == v, "Wrong iterator.");
     127          ++i;
     128        }
     129      }
     130    }
     131    check(cnt == i, "Wrong iterator.");
    110132  }
    111133
    112134  template <class Graph>
    113   void checkGraphIterators() {
    114     checkDigraphIterators<Graph>();
    115     typedef typename Graph::Edge Edge;
    116     typedef typename Graph::EdgeIt EdgeIt;
    117     typedef typename Graph::IncEdgeIt IncEdgeIt;
     135  void checkGraphConEdgeList(const Graph &G, int cnt) {
     136    int i = 0;
     137    for (typename Graph::NodeIt u(G); u != INVALID; ++u) {
     138      for (typename Graph::NodeIt v(G); v != INVALID; ++v) {
     139        for (ConEdgeIt<Graph> e(G, u, v); e != INVALID; ++e) {
     140          check((G.u(e) == u && G.v(e) == v) ||
     141                (G.u(e) == v && G.v(e) == u), "Wrong iterator.");
     142          i += u == v ? 2 : 1;
     143        }
     144      }
     145    }
     146    check(2 * cnt == i, "Wrong iterator.");
    118147  }
    119148
    120   // Structure returned by addPetersen()
    121   template<class Digraph>
    122   struct PetStruct
    123   {
    124     // Vector containing the outer nodes
    125     std::vector<typename Digraph::Node> outer;
    126     // Vector containing the inner nodes
    127     std::vector<typename Digraph::Node> inner;
    128     // Vector containing the arcs of the inner circle
    129     std::vector<typename Digraph::Arc> incir;
    130     // Vector containing the arcs of the outer circle
    131     std::vector<typename Digraph::Arc> outcir;
    132     // Vector containing the chord arcs
    133     std::vector<typename Digraph::Arc> chords;
    134   };
    135 
    136   // Adds the reverse pair of all arcs to a digraph
    137   template<class Digraph>
    138   void bidirDigraph(Digraph &G)
    139   {
    140     typedef typename Digraph::Arc Arc;
    141     typedef typename Digraph::ArcIt ArcIt;
    142 
    143     std::vector<Arc> ee;
    144 
    145     for(ArcIt e(G);e!=INVALID;++e) ee.push_back(e);
    146 
    147     for(int i=0;i<int(ee.size());++i)
    148       G.addArc(G.target(ee[i]),G.source(ee[i]));
    149   }
    150 
    151   // Adds a Petersen digraph to G.
    152   // Returns the nodes and arcs of the generated digraph.
    153   template<typename Digraph>
    154   PetStruct<Digraph> addPetersen(Digraph &G,int num = 5)
    155   {
    156     PetStruct<Digraph> n;
    157 
    158     for(int i=0;i<num;i++) {
    159       n.outer.push_back(G.addNode());
    160       n.inner.push_back(G.addNode());
    161     }
    162 
    163     for(int i=0;i<num;i++) {
    164       n.chords.push_back(G.addArc(n.outer[i],n.inner[i]));
    165       n.outcir.push_back(G.addArc(n.outer[i],n.outer[(i+1) % num]));
    166       n.incir.push_back(G.addArc(n.inner[i],n.inner[(i+2) % num]));
    167     }
    168 
    169     return n;
    170   }
    171 
    172   // Checks the bidirectioned Petersen digraph
    173   template<class Digraph>
    174   void checkBidirPetersen(const Digraph &G, int num = 5)
    175   {
    176     typedef typename Digraph::NodeIt NodeIt;
    177 
    178     checkGraphNodeList(G, 2 * num);
    179     checkGraphArcList(G, 6 * num);
    180 
    181     for(NodeIt n(G);n!=INVALID;++n) {
    182       checkGraphInArcList(G, n, 3);
    183       checkGraphOutArcList(G, n, 3);
     149  template <typename Graph>
     150  void checkArcDirections(const Graph& G) {
     151    for (typename Graph::ArcIt a(G); a != INVALID; ++a) {
     152      check(G.source(a) == G.target(G.oppositeArc(a)), "Wrong direction");
     153      check(G.target(a) == G.source(G.oppositeArc(a)), "Wrong direction");
     154      check(G.direct(a, G.direction(a)) == a, "Wrong direction");
    184155    }
    185156  }
    186157
    187   // Structure returned by addUPetersen()
    188   template<class Graph>
    189   struct UPetStruct
    190   {
    191     // Vector containing the outer nodes
    192     std::vector<typename Graph::Node> outer;
    193     // Vector containing the inner nodes
    194     std::vector<typename Graph::Node> inner;
    195     // Vector containing the edges of the inner circle
    196     std::vector<typename Graph::Edge> incir;
    197     // Vector containing the edges of the outer circle
    198     std::vector<typename Graph::Edge> outcir;
    199     // Vector containing the chord edges
    200     std::vector<typename Graph::Edge> chords;
    201   };
    202 
    203   // Adds a Petersen graph to \c G.
    204   // Returns the nodes and edges of the generated graph.
    205   template<typename Graph>
    206   UPetStruct<Graph> addUPetersen(Graph &G,int num=5)
    207   {
    208     UPetStruct<Graph> n;
    209 
    210     for(int i=0;i<num;i++) {
    211       n.outer.push_back(G.addNode());
    212       n.inner.push_back(G.addNode());
    213     }
    214 
    215     for(int i=0;i<num;i++) {
    216       n.chords.push_back(G.addEdge(n.outer[i],n.inner[i]));
    217       n.outcir.push_back(G.addEdge(n.outer[i],n.outer[(i+1)%num]));
    218       n.incir.push_back(G.addEdge(n.inner[i],n.inner[(i+2)%num]));
    219     }
    220 
    221     return n;
    222   }
    223 
    224   // Checks the undirected Petersen graph
    225   template<class Graph>
    226   void checkUndirPetersen(const Graph &G, int num = 5)
    227   {
    228     typedef typename Graph::NodeIt NodeIt;
    229 
    230     checkGraphNodeList(G, 2 * num);
    231     checkGraphEdgeList(G, 3 * num);
    232     checkGraphArcList(G, 6 * num);
    233 
    234     for(NodeIt n(G);n!=INVALID;++n) {
    235       checkGraphIncEdgeList(G, n, 3);
     158  template <typename Graph>
     159  void checkNodeIds(const Graph& G) {
     160    std::set<int> values;
     161    for (typename Graph::NodeIt n(G); n != INVALID; ++n) {
     162      check(G.nodeFromId(G.id(n)) == n, "Wrong id");
     163      check(values.find(G.id(n)) == values.end(), "Wrong id");
     164      check(G.id(n) <= G.maxNodeId(), "Wrong maximum id");
     165      values.insert(G.id(n));
    236166    }
    237167  }
    238168
    239   template <class Digraph>
    240   void checkDigraph() {
    241     const int num = 5;
    242     Digraph G;
    243     checkGraphNodeList(G, 0);
    244     checkGraphArcList(G, 0);
    245     addPetersen(G, num);
    246     bidirDigraph(G);
    247     checkBidirPetersen(G, num);
     169  template <typename Graph>
     170  void checkArcIds(const Graph& G) {
     171    std::set<int> values;
     172    for (typename Graph::ArcIt a(G); a != INVALID; ++a) {
     173      check(G.arcFromId(G.id(a)) == a, "Wrong id");
     174      check(values.find(G.id(a)) == values.end(), "Wrong id");
     175      check(G.id(a) <= G.maxArcId(), "Wrong maximum id");
     176      values.insert(G.id(a));
     177    }
    248178  }
    249179
    250   template <class Graph>
    251   void checkGraph() {
    252     const int num = 5;
    253     Graph G;
    254     checkGraphNodeList(G, 0);
    255     checkGraphEdgeList(G, 0);
    256     addUPetersen(G, num);
    257     checkUndirPetersen(G, num);
     180  template <typename Graph>
     181  void checkEdgeIds(const Graph& G) {
     182    std::set<int> values;
     183    for (typename Graph::EdgeIt e(G); e != INVALID; ++e) {
     184      check(G.edgeFromId(G.id(e)) == e, "Wrong id");
     185      check(values.find(G.id(e)) == values.end(), "Wrong id");
     186      check(G.id(e) <= G.maxEdgeId(), "Wrong maximum id");
     187      values.insert(G.id(e));
     188    }
    258189  }
     190
     191  template <typename Graph>
     192  void checkGraphNodeMap(const Graph& G) {
     193    typedef typename Graph::Node Node;
     194    typedef typename Graph::NodeIt NodeIt;
     195
     196    typedef typename Graph::template NodeMap<int> IntNodeMap;
     197    IntNodeMap map(G, 42);
     198    for (NodeIt it(G); it != INVALID; ++it) {
     199      check(map[it] == 42, "Wrong map constructor.");
     200    }
     201    int s = 0;
     202    for (NodeIt it(G); it != INVALID; ++it) {
     203      map[it] = 0;
     204      check(map[it] == 0, "Wrong operator[].");
     205      map.set(it, s);
     206      check(map[it] == s, "Wrong set.");
     207      ++s;
     208    }
     209    s = s * (s - 1) / 2;
     210    for (NodeIt it(G); it != INVALID; ++it) {
     211      s -= map[it];
     212    }
     213    check(s == 0, "Wrong sum.");
     214
     215    map = constMap<Node>(12);
     216    for (NodeIt it(G); it != INVALID; ++it) {
     217      check(map[it] == 12, "Wrong operator[].");
     218    }
     219  }
     220
     221  template <typename Graph>
     222  void checkGraphArcMap(const Graph& G) {
     223    typedef typename Graph::Arc Arc;
     224    typedef typename Graph::ArcIt ArcIt;
     225
     226    typedef typename Graph::template ArcMap<int> IntArcMap;
     227    IntArcMap map(G, 42);
     228    for (ArcIt it(G); it != INVALID; ++it) {
     229      check(map[it] == 42, "Wrong map constructor.");
     230    }
     231    int s = 0;
     232    for (ArcIt it(G); it != INVALID; ++it) {
     233      map[it] = 0;
     234      check(map[it] == 0, "Wrong operator[].");
     235      map.set(it, s);
     236      check(map[it] == s, "Wrong set.");
     237      ++s;
     238    }
     239    s = s * (s - 1) / 2;
     240    for (ArcIt it(G); it != INVALID; ++it) {
     241      s -= map[it];
     242    }
     243    check(s == 0, "Wrong sum.");
     244
     245    map = constMap<Arc>(12);
     246    for (ArcIt it(G); it != INVALID; ++it) {
     247      check(map[it] == 12, "Wrong operator[].");
     248    }
     249  }
     250
     251  template <typename Graph>
     252  void checkGraphEdgeMap(const Graph& G) {
     253    typedef typename Graph::Edge Edge;
     254    typedef typename Graph::EdgeIt EdgeIt;
     255
     256    typedef typename Graph::template EdgeMap<int> IntEdgeMap;
     257    IntEdgeMap map(G, 42);
     258    for (EdgeIt it(G); it != INVALID; ++it) {
     259      check(map[it] == 42, "Wrong map constructor.");
     260    }
     261    int s = 0;
     262    for (EdgeIt it(G); it != INVALID; ++it) {
     263      map[it] = 0;
     264      check(map[it] == 0, "Wrong operator[].");
     265      map.set(it, s);
     266      check(map[it] == s, "Wrong set.");
     267      ++s;
     268    }
     269    s = s * (s - 1) / 2;
     270    for (EdgeIt it(G); it != INVALID; ++it) {
     271      s -= map[it];
     272    }
     273    check(s == 0, "Wrong sum.");
     274
     275    map = constMap<Edge>(12);
     276    for (EdgeIt it(G); it != INVALID; ++it) {
     277      check(map[it] == 12, "Wrong operator[].");
     278    }
     279  }
     280
    259281
    260282} //namespace lemon
    261283