COIN-OR::LEMON - Graph Library

Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • test/maps_test.cc

    r726 r695  
    2323#include <lemon/concepts/maps.h>
    2424#include <lemon/maps.h>
    25 #include <lemon/list_graph.h>
    2625#include <lemon/smart_graph.h>
    27 #include <lemon/adaptors.h>
    28 #include <lemon/dfs.h>
    2926
    3027#include "test_tools.h"
     
    6461typedef ReadWriteMap<A, bool> BoolWriteMap;
    6562typedef ReferenceMap<A, bool, bool&, const bool&> BoolRefMap;
    66 
    67 template<typename Map1, typename Map2, typename ItemIt>
    68 void compareMap(const Map1& map1, const Map2& map2, ItemIt it) {
    69   for (; it != INVALID; ++it)
    70     check(map1[it] == map2[it], "The maps are not equal");
    71 }
    7263
    7364int main()
     
    339330  {
    340331    typedef std::vector<int> vec;
    341     checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >();
    342     checkConcept<WriteMap<int, bool>,
    343                  LoggerBoolMap<std::back_insert_iterator<vec> > >();
    344 
    345332    vec v1;
    346333    vec v2(10);
     
    362349          it != map2.end(); ++it )
    363350      check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
    364    
    365     typedef ListDigraph Graph;
    366     DIGRAPH_TYPEDEFS(Graph);
    367     Graph gr;
    368 
    369     Node n0 = gr.addNode();
    370     Node n1 = gr.addNode();
    371     Node n2 = gr.addNode();
    372     Node n3 = gr.addNode();
    373    
    374     gr.addArc(n3, n0);
    375     gr.addArc(n3, n2);
    376     gr.addArc(n0, n2);
    377     gr.addArc(n2, n1);
    378     gr.addArc(n0, n1);
    379    
    380     {
    381       std::vector<Node> v;
    382       dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
    383 
    384       check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
    385             "Something is wrong with LoggerBoolMap");
    386     }
    387     {
    388       std::vector<Node> v(countNodes(gr));
    389       dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
    390      
    391       check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
    392             "Something is wrong with LoggerBoolMap");
    393     }
    394   }
    395  
    396   // IdMap, RangeIdMap
    397   {
    398     typedef ListDigraph Graph;
    399     DIGRAPH_TYPEDEFS(Graph);
    400 
    401     checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
    402     checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
    403     checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
    404     checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
    405    
    406     Graph gr;
    407     IdMap<Graph, Node> nmap(gr);
    408     IdMap<Graph, Arc> amap(gr);
    409     RangeIdMap<Graph, Node> nrmap(gr);
    410     RangeIdMap<Graph, Arc> armap(gr);
    411    
    412     Node n0 = gr.addNode();
    413     Node n1 = gr.addNode();
    414     Node n2 = gr.addNode();
    415    
    416     Arc a0 = gr.addArc(n0, n1);
    417     Arc a1 = gr.addArc(n0, n2);
    418     Arc a2 = gr.addArc(n2, n1);
    419     Arc a3 = gr.addArc(n2, n0);
    420    
    421     check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
    422     check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
    423     check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
    424 
    425     check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");
    426     check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");
    427     check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");
    428     check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");
    429 
    430     check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
    431     check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
    432    
    433     check(nrmap.size() == 3 && armap.size() == 4,
    434           "Wrong RangeIdMap::size()");
    435 
    436     check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
    437     check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
    438     check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
    439    
    440     check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
    441     check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
    442     check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
    443     check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");
    444 
    445     check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
    446     check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
    447    
    448     gr.erase(n1);
    449    
    450     if (nrmap[n0] == 1) nrmap.swap(n0, n2);
    451     nrmap.swap(n2, n0);
    452     if (armap[a1] == 1) armap.swap(a1, a3);
    453     armap.swap(a3, a1);
    454    
    455     check(nrmap.size() == 2 && armap.size() == 2,
    456           "Wrong RangeIdMap::size()");
    457 
    458     check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
    459     check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
    460    
    461     check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
    462     check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
    463 
    464     check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
    465     check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
    466   }
    467  
    468   // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
    469   {
    470     typedef ListGraph Graph;
    471     GRAPH_TYPEDEFS(Graph);
    472    
    473     checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
    474     checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
    475     checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
    476     checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();
    477     checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();
    478     checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();
    479 
    480     Graph gr;
    481     Node n0 = gr.addNode();
    482     Node n1 = gr.addNode();
    483     Node n2 = gr.addNode();
    484    
    485     gr.addEdge(n0,n1);
    486     gr.addEdge(n1,n2);
    487     gr.addEdge(n0,n2);
    488     gr.addEdge(n2,n1);
    489     gr.addEdge(n1,n2);
    490     gr.addEdge(n0,n1);
    491    
    492     for (EdgeIt e(gr); e != INVALID; ++e) {
    493       check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
    494       check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
    495     }
    496    
    497     compareMap(sourceMap(orienter(gr, constMap<Edge, bool>(true))),
    498                targetMap(orienter(gr, constMap<Edge, bool>(false))),
    499                EdgeIt(gr));
    500 
    501     typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
    502     Digraph dgr(gr, constMap<Edge, bool>(true));
    503     OutDegMap<Digraph> odm(dgr);
    504     InDegMap<Digraph> idm(dgr);
    505    
    506     check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
    507     check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
    508    
    509     gr.addEdge(n2, n0);
    510 
    511     check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
    512     check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
    513   }
    514  
    515   // CrossRefMap
    516   {
    517     typedef ListDigraph Graph;
    518     DIGRAPH_TYPEDEFS(Graph);
    519 
    520     checkConcept<ReadWriteMap<Node, int>,
    521                  CrossRefMap<Graph, Node, int> >();
    522     checkConcept<ReadWriteMap<Node, bool>,
    523                  CrossRefMap<Graph, Node, bool> >();
    524     checkConcept<ReadWriteMap<Node, double>,
    525                  CrossRefMap<Graph, Node, double> >();
    526    
    527     Graph gr;
    528     typedef CrossRefMap<Graph, Node, char> CRMap;
    529     CRMap map(gr);
    530    
    531     Node n0 = gr.addNode();
    532     Node n1 = gr.addNode();
    533     Node n2 = gr.addNode();
    534    
    535     map.set(n0, 'A');
    536     map.set(n1, 'B');
    537     map.set(n2, 'C');
    538    
    539     check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
    540           "Wrong CrossRefMap");
    541     check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
    542           "Wrong CrossRefMap");
    543     check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,
    544           "Wrong CrossRefMap");
    545     check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
    546           "Wrong CrossRefMap::count()");
    547    
    548     CRMap::ValueIt it = map.beginValue();
    549     check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
    550           it == map.endValue(), "Wrong value iterator");
    551    
    552     map.set(n2, 'A');
    553 
    554     check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
    555           "Wrong CrossRefMap");
    556     check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");
    557     check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
    558     check(map('C') == INVALID && map.inverse()['C'] == INVALID,
    559           "Wrong CrossRefMap");
    560     check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0,
    561           "Wrong CrossRefMap::count()");
    562 
    563     it = map.beginValue();
    564     check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' &&
    565           it == map.endValue(), "Wrong value iterator");
    566 
    567     map.set(n0, 'C');
    568 
    569     check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
    570           "Wrong CrossRefMap");
    571     check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
    572     check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
    573     check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
    574     check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
    575           "Wrong CrossRefMap::count()");
    576 
    577     it = map.beginValue();
    578     check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
    579           it == map.endValue(), "Wrong value iterator");
    580351  }
    581352
     
    776547    }
    777548
    778     for (Ivm::ValueIt vit = map1.beginValue();
     549    for (Ivm::ValueIterator vit = map1.beginValue();
    779550         vit != map1.endValue(); ++vit) {
    780551      check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit,
    781             "Wrong ValueIt");
     552            "Wrong ValueIterator");
    782553    }
    783554
Note: See TracChangeset for help on using the changeset viewer.