Changeset - r989:24b3f18ed9e2
« 988:d39535
999:c279b1 »
992:e20fec »
990:dca9ee »
gravatar
kpeter (Peter Kovacs)
kpeter@inf.elte.hu
Improve graph_copy_test.cc
0 1 0
default
1 file changed with 37 insertions and 31 deletions:
test/graph_copy_test.cc
37
31
↑ Collapse diff ↑
test/graph_copy_test.cc
Ignore white space 12 line context
... ... 
@@ -15,20 +15,22 @@
15 15 
 * purpose.
16 16 
 *
17 17 
 */
18 18 

			




	19
	19
	
		
#include <lemon/smart_graph.h>


			




	20
	20
	
		
#include <lemon/list_graph.h>


			




	
	21
	
		
#include <lemon/static_graph.h>


			




	21
	22
	
		
#include <lemon/lgf_reader.h>


			




	22
	23
	
		
#include <lemon/error.h>


			




	23
	24
	
		

			




	24
	25
	
		
#include "test_tools.h"


			




	25
	26
	
		

			




	26
	27
	
		
using namespace std;


			




	27
	28
	
		
using namespace lemon;


			




	28
	29
	
		

			




	
	30
	
		
template <typename GR>


			




	29
	31
	
		
void digraph_copy_test() {


			




	30
	32
	
		
  const int nn = 10;


			




	31
	33
	
		

			




	32
	34
	
		
  // Build a digraph


			




	33
	35
	
		
  SmartDigraph from;


			




	34
	36
	
		
  SmartDigraph::NodeMap<int> fnm(from);


			




	...
	...
	
		
@@ -48,25 +50,25 @@


			




	48
	50
	
		
    for (int j = 0; j < nn; ++j) {


			




	49
	51
	
		
      SmartDigraph::Arc arc = from.addArc(fnv[i], fnv[j]);


			




	50
	52
	
		
      fam[arc] = i + j * j;


			




	51
	53
	
		
      if (i == 0 && j == 0) fa = arc;


			




	52
	54
	
		
    }


			




	53
	55
	
		
  }


			




	
	56
	
		
  


			




	
	57
	
		
  // Test digraph copy


			




	
	58
	
		
  GR to;


			




	
	59
	
		
  typename GR::template NodeMap<int> tnm(to);


			




	
	60
	
		
  typename GR::template ArcMap<int> tam(to);


			




	
	61
	
		
  typename GR::Node tn;


			




	
	62
	
		
  typename GR::Arc ta;


			




	54
	63
	
		

			




	55
	
	
		
  // Test digraph copy


			




	56
	
	
		
  ListDigraph to;


			




	57
	
	
		
  ListDigraph::NodeMap<int> tnm(to);


			




	58
	
	
		
  ListDigraph::ArcMap<int> tam(to);


			




	59
	
	
		
  ListDigraph::Node tn;


			




	60
	
	
		
  ListDigraph::Arc ta;


			




	
	64
	
		
  SmartDigraph::NodeMap<typename GR::Node> nr(from);


			




	
	65
	
		
  SmartDigraph::ArcMap<typename GR::Arc> er(from);


			




	61
	66
	
		

			




	62
	
	
		
  SmartDigraph::NodeMap<ListDigraph::Node> nr(from);


			




	63
	
	
		
  SmartDigraph::ArcMap<ListDigraph::Arc> er(from);


			




	64
	
	
		

			




	65
	
	
		
  ListDigraph::NodeMap<SmartDigraph::Node> ncr(to);


			




	66
	
	
		
  ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);


			




	
	67
	
		
  typename GR::template NodeMap<SmartDigraph::Node> ncr(to);


			




	
	68
	
		
  typename GR::template ArcMap<SmartDigraph::Arc> ecr(to);


			




	67
	69
	
		

			




	68
	70
	
		
  digraphCopy(from, to).


			




	69
	71
	
		
    nodeMap(fnm, tnm).arcMap(fam, tam).


			




	70
	72
	
		
    nodeRef(nr).arcRef(er).


			




	71
	73
	
		
    nodeCrossRef(ncr).arcCrossRef(ecr).


			




	72
	74
	
		
    node(fn, tn).arc(fa, ta).run();


			




	...
	...
	
		
@@ -83,29 +85,30 @@


			




	83
	85
	
		
    check(ecr[er[it]] == it, "Wrong copy.");


			




	84
	86
	
		
    check(fam[it] == tam[er[it]], "Wrong copy.");


			




	85
	87
	
		
    check(nr[from.source(it)] == to.source(er[it]), "Wrong copy.");


			




	86
	88
	
		
    check(nr[from.target(it)] == to.target(er[it]), "Wrong copy.");


			




	87
	89
	
		
  }


			




	88
	90
	
		

			




	89
	
	
		
  for (ListDigraph::NodeIt it(to); it != INVALID; ++it) {


			




	
	91
	
		
  for (typename GR::NodeIt it(to); it != INVALID; ++it) {


			




	90
	92
	
		
    check(nr[ncr[it]] == it, "Wrong copy.");


			




	91
	93
	
		
  }


			




	92
	94
	
		

			




	93
	
	
		
  for (ListDigraph::ArcIt it(to); it != INVALID; ++it) {


			




	
	95
	
		
  for (typename GR::ArcIt it(to); it != INVALID; ++it) {


			




	94
	96
	
		
    check(er[ecr[it]] == it, "Wrong copy.");


			




	95
	97
	
		
  }


			




	96
	98
	
		
  check(tn == nr[fn], "Wrong copy.");


			




	97
	99
	
		
  check(ta == er[fa], "Wrong copy.");


			




	98
	100
	
		

			




	99
	101
	
		
  // Test repeated copy


			




	100
	102
	
		
  digraphCopy(from, to).run();


			




	101
	103
	
		
  


			




	102
	104
	
		
  check(countNodes(from) == countNodes(to), "Wrong copy.");


			




	103
	105
	
		
  check(countArcs(from) == countArcs(to), "Wrong copy.");


			




	104
	106
	
		
}


			




	105
	107
	
		

			




	
	108
	
		
template <typename GR>


			




	106
	109
	
		
void graph_copy_test() {


			




	107
	110
	
		
  const int nn = 10;


			




	108
	111
	
		

			




	109
	112
	
		
  // Build a graph


			




	110
	113
	
		
  SmartGraph from;


			




	111
	114
	
		
  SmartGraph::NodeMap<int> fnm(from);


			




	...
	...
	
		
@@ -132,27 +135,27 @@


			




	132
	135
	
		
      if (i == 0 && j == 0) fa = from.direct(edge, true);


			




	133
	136
	
		
      if (i == 0 && j == 0) fe = edge;


			




	134
	137
	
		
    }


			




	135
	138
	
		
  }


			




	136
	139
	
		

			




	137
	140
	
		
  // Test graph copy


			




	138
	
	
		
  ListGraph to;


			




	139
	
	
		
  ListGraph::NodeMap<int> tnm(to);


			




	140
	
	
		
  ListGraph::ArcMap<int> tam(to);


			




	141
	
	
		
  ListGraph::EdgeMap<int> tem(to);


			




	142
	
	
		
  ListGraph::Node tn;


			




	143
	
	
		
  ListGraph::Arc ta;


			




	144
	
	
		
  ListGraph::Edge te;


			




	
	141
	
		
  GR to;


			




	
	142
	
		
  typename GR::template NodeMap<int> tnm(to);


			




	
	143
	
		
  typename GR::template ArcMap<int> tam(to);


			




	
	144
	
		
  typename GR::template EdgeMap<int> tem(to);


			




	
	145
	
		
  typename GR::Node tn;


			




	
	146
	
		
  typename GR::Arc ta;


			




	
	147
	
		
  typename GR::Edge te;


			




	145
	148
	
		

			




	146
	
	
		
  SmartGraph::NodeMap<ListGraph::Node> nr(from);


			




	147
	
	
		
  SmartGraph::ArcMap<ListGraph::Arc> ar(from);


			




	148
	
	
		
  SmartGraph::EdgeMap<ListGraph::Edge> er(from);


			




	
	149
	
		
  SmartGraph::NodeMap<typename GR::Node> nr(from);


			




	
	150
	
		
  SmartGraph::ArcMap<typename GR::Arc> ar(from);


			




	
	151
	
		
  SmartGraph::EdgeMap<typename GR::Edge> er(from);


			




	149
	152
	
		

			




	150
	
	
		
  ListGraph::NodeMap<SmartGraph::Node> ncr(to);


			




	151
	
	
		
  ListGraph::ArcMap<SmartGraph::Arc> acr(to);


			




	152
	
	
		
  ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);


			




	
	153
	
		
  typename GR::template NodeMap<SmartGraph::Node> ncr(to);


			




	
	154
	
		
  typename GR::template ArcMap<SmartGraph::Arc> acr(to);


			




	
	155
	
		
  typename GR::template EdgeMap<SmartGraph::Edge> ecr(to);


			




	153
	156
	
		

			




	154
	157
	
		
  graphCopy(from, to).


			




	155
	158
	
		
    nodeMap(fnm, tnm).arcMap(fam, tam).edgeMap(fem, tem).


			




	156
	159
	
		
    nodeRef(nr).arcRef(ar).edgeRef(er).


			




	157
	160
	
		
    nodeCrossRef(ncr).arcCrossRef(acr).edgeCrossRef(ecr).


			




	158
	161
	
		
    node(fn, tn).arc(fa, ta).edge(fe, te).run();


			




	...
	...
	
		
@@ -181,20 +184,20 @@


			




	181
	184
	
		
    check(nr[from.v(it)] == to.u(er[it]) || nr[from.v(it)] == to.v(er[it]),


			




	182
	185
	
		
          "Wrong copy.");


			




	183
	186
	
		
    check((from.u(it) != from.v(it)) == (to.u(er[it]) != to.v(er[it])),


			




	184
	187
	
		
          "Wrong copy.");


			




	185
	188
	
		
  }


			




	186
	189
	
		

			




	187
	
	
		
  for (ListGraph::NodeIt it(to); it != INVALID; ++it) {


			




	
	190
	
		
  for (typename GR::NodeIt it(to); it != INVALID; ++it) {


			




	188
	191
	
		
    check(nr[ncr[it]] == it, "Wrong copy.");


			




	189
	192
	
		
  }


			




	190
	193
	
		

			




	191
	
	
		
  for (ListGraph::ArcIt it(to); it != INVALID; ++it) {


			




	
	194
	
		
  for (typename GR::ArcIt it(to); it != INVALID; ++it) {


			




	192
	195
	
		
    check(ar[acr[it]] == it, "Wrong copy.");


			




	193
	196
	
		
  }


			




	194
	
	
		
  for (ListGraph::EdgeIt it(to); it != INVALID; ++it) {


			




	
	197
	
		
  for (typename GR::EdgeIt it(to); it != INVALID; ++it) {


			




	195
	198
	
		
    check(er[ecr[it]] == it, "Wrong copy.");


			




	196
	199
	
		
  }


			




	197
	200
	
		
  check(tn == nr[fn], "Wrong copy.");


			




	198
	201
	
		
  check(ta == ar[fa], "Wrong copy.");


			




	199
	202
	
		
  check(te == er[fe], "Wrong copy.");


			




	200
	203
	
		

			




	...
	...
	
		
@@ -205,11 +208,14 @@


			




	205
	208
	
		
  check(countEdges(from) == countEdges(to), "Wrong copy.");


			




	206
	209
	
		
  check(countArcs(from) == countArcs(to), "Wrong copy.");


			




	207
	210
	
		
}


			




	208
	211
	
		

			




	209
	212
	
		

			




	210
	213
	
		
int main() {


			




	211
	
	
		
  digraph_copy_test();


			




	212
	
	
		
  graph_copy_test();


			




	
	214
	
		
  digraph_copy_test<SmartDigraph>();


			




	
	215
	
		
  digraph_copy_test<ListDigraph>();


			




	
	216
	
		
  digraph_copy_test<StaticDigraph>();


			




	
	217
	
		
  graph_copy_test<SmartGraph>();


			




	
	218
	
		
  graph_copy_test<ListGraph>();


			




	213
	219
	
		

			




	214
	220
	
		
  return 0;


			




	215
	221
	
		
}


			




        

    






    
    



    


    

     
    
0 comments (0 inline)