diff -r 03e4d2128efe -r f30867b359a8 test/graph_copy_test.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/graph_copy_test.cc	Fri Nov 03 14:20:24 2006 +0000
@@ -0,0 +1,312 @@
+#include <lemon/smart_graph.h>
+#include <lemon/list_graph.h>
+#include <lemon/graph_reader.h>
+#include <lemon/graph_utils.h>
+#include <lemon/error.h>
+
+#include "test_tools.h"
+
+using namespace std;
+using namespace lemon;
+
+void graph_copy_test() {
+  const int nn = 10;
+
+  SmartGraph source;
+  SmartGraph::NodeMap<int> snm(source);
+  SmartGraph::EdgeMap<int> sem(source);
+  SmartGraph::Node sn = INVALID;
+  SmartGraph::Edge se = INVALID;
+
+  std::vector<SmartGraph::Node> snv;
+  for (int i = 0; i < nn; ++i) {
+    SmartGraph::Node node = source.addNode();
+    snv.push_back(node);
+    snm[node] = i * i;
+    if (i == 0) sn = node;
+  }
+
+  for (int i = 0; i < nn; ++i) {
+    for (int j = 0; j < nn; ++j) {
+      SmartGraph::Edge edge = source.addEdge(snv[i], snv[j]);
+      sem[edge] = i + j * j;
+      if (i == 0 && j == 0) se = edge;
+    }
+  }
+
+  ListGraph target;
+  ListGraph::NodeMap<int> tnm(target);
+  ListGraph::EdgeMap<int> tem(target);
+  ListGraph::Node tn;
+  ListGraph::Edge te;
+
+  SmartGraph::NodeMap<ListGraph::Node> nr(source);
+  SmartGraph::EdgeMap<ListGraph::Edge> er(source);
+
+  ListGraph::NodeMap<SmartGraph::Node> ncr(target);
+  ListGraph::EdgeMap<SmartGraph::Edge> ecr(target);
+
+  GraphCopy<ListGraph, SmartGraph>(target, source).
+    nodeMap(tnm, snm).edgeMap(tem, sem).
+    nodeRef(nr).edgeRef(er).
+    nodeCrossRef(ncr).edgeCrossRef(ecr).
+    node(tn, sn).edge(te, se).run();
+
+  for (SmartGraph::NodeIt it(source); it != INVALID; ++it) {
+    check(ncr[nr[it]] == it, "Wrong copy.");
+    check(snm[it] == tnm[nr[it]], "Wrong copy.");
+  }
+
+  for (SmartGraph::EdgeIt it(source); it != INVALID; ++it) {
+    check(ecr[er[it]] == it, "Wrong copy.");
+    check(sem[it] == tem[er[it]], "Wrong copy.");
+    check(nr[source.source(it)] == 
+                 target.source(er[it]), "Wrong copy.");
+    check(nr[source.target(it)] == 
+                 target.target(er[it]), "Wrong copy.");
+  }
+
+  for (ListGraph::NodeIt it(target); it != INVALID; ++it) {
+    check(nr[ncr[it]] == it, "Wrong copy.");
+  }
+
+  for (ListGraph::EdgeIt it(target); it != INVALID; ++it) {
+    check(er[ecr[it]] == it, "Wrong copy.");
+  }
+  check(tn == nr[sn], "Wrong copy.");
+  check(te == er[se], "Wrong copy.");
+}
+
+void ugraph_copy_test() {
+  const int nn = 10;
+
+  SmartUGraph source;
+  SmartUGraph::NodeMap<int> snm(source);
+  SmartUGraph::EdgeMap<int> sem(source);
+  SmartUGraph::UEdgeMap<int> suem(source);
+  SmartUGraph::Node sn = INVALID;
+  SmartUGraph::Edge se = INVALID;
+  SmartUGraph::UEdge sue = INVALID;
+
+  std::vector<SmartGraph::Node> snv;
+  for (int i = 0; i < nn; ++i) {
+    SmartUGraph::Node node = source.addNode();
+    snv.push_back(node);
+    snm[node] = i * i;
+    if (i == 0) sn = node;
+  }
+
+  for (int i = 0; i < nn; ++i) {
+    for (int j = 0; j < nn; ++j) {
+      SmartUGraph::UEdge edge = source.addEdge(snv[i], snv[j]);
+      suem[edge] = i * i + j * j;
+      sem[source.direct(edge, true)] = i + j * j;
+      sem[source.direct(edge, false)] = i * i + j;
+      if (i == 0 && j == 0) se = source.direct(edge, true);
+      if (i == 0 && j == 0) sue = edge;
+    }
+  }
+  
+  ListUGraph target;
+  ListUGraph::NodeMap<int> tnm(target);
+  ListUGraph::EdgeMap<int> tem(target);
+  ListUGraph::UEdgeMap<int> tuem(target);
+  ListUGraph::Node tn;
+  ListUGraph::Edge te;
+  ListUGraph::UEdge tue;
+
+  SmartUGraph::NodeMap<ListUGraph::Node> nr(source);
+  SmartUGraph::EdgeMap<ListUGraph::Edge> er(source);
+  SmartUGraph::UEdgeMap<ListUGraph::UEdge> uer(source);
+
+  ListUGraph::NodeMap<SmartUGraph::Node> ncr(target);
+  ListUGraph::EdgeMap<SmartUGraph::Edge> ecr(target);
+  ListUGraph::UEdgeMap<SmartUGraph::UEdge> uecr(target);
+
+  UGraphCopy<ListUGraph, SmartUGraph>(target, source).
+    nodeMap(tnm, snm).edgeMap(tem, sem).uEdgeMap(tuem, suem).
+    nodeRef(nr).edgeRef(er).uEdgeRef(uer).
+    nodeCrossRef(ncr).edgeCrossRef(ecr).uEdgeCrossRef(uecr).
+    node(tn, sn).edge(te, se).uEdge(tue, sue).run();
+
+  for (SmartUGraph::NodeIt it(source); it != INVALID; ++it) {
+    check(ncr[nr[it]] == it, "Wrong copy.");
+    check(snm[it] == tnm[nr[it]], "Wrong copy.");
+  }
+
+  for (SmartUGraph::EdgeIt it(source); it != INVALID; ++it) {
+    check(ecr[er[it]] == it, "Wrong copy.");
+    check(sem[it] == tem[er[it]], "Wrong copy.");
+    check(nr[source.source(it)] == 
+                 target.source(er[it]), "Wrong copy.");
+    check(nr[source.target(it)] == 
+                 target.target(er[it]), "Wrong copy.");
+  }
+
+  for (SmartUGraph::UEdgeIt it(source); it != INVALID; ++it) {
+    check(uecr[uer[it]] == it, "Wrong copy.");
+    check(suem[it] == tuem[uer[it]], "Wrong copy.");
+    check(nr[source.source(it)] == target.source(uer[it]) ||
+                 nr[source.source(it)] == target.target(uer[it]), 
+                 "Wrong copy.");
+    check(nr[source.target(it)] == target.source(uer[it]) ||
+                 nr[source.target(it)] == target.target(uer[it]), 
+                 "Wrong copy.");
+    check((source.source(it) != source.target(it)) ==
+                 (target.source(uer[it]) != target.target(uer[it])), 
+                 "Wrong copy.");
+  }
+
+  for (ListUGraph::NodeIt it(target); it != INVALID; ++it) {
+    check(nr[ncr[it]] == it, "Wrong copy.");
+  }
+
+  for (ListUGraph::EdgeIt it(target); it != INVALID; ++it) {
+    check(er[ecr[it]] == it, "Wrong copy.");
+  }
+  for (ListUGraph::UEdgeIt it(target); it != INVALID; ++it) {
+    check(uer[uecr[it]] == it, "Wrong copy.");
+  }
+  check(tn == nr[sn], "Wrong copy.");
+  check(te == er[se], "Wrong copy.");
+  check(tue == uer[sue], "Wrong copy.");
+}
+
+void bpugraph_copy_test() {
+  const int nn = 10;
+
+  SmartBpUGraph source;
+  SmartBpUGraph::ANodeMap<int> sanm(source);
+  SmartBpUGraph::BNodeMap<int> sbnm(source);
+  SmartBpUGraph::NodeMap<int> snm(source);
+  SmartBpUGraph::EdgeMap<int> sem(source);
+  SmartBpUGraph::UEdgeMap<int> suem(source);
+  SmartBpUGraph::Node sn = INVALID;
+  SmartBpUGraph::Edge se = INVALID;
+  SmartBpUGraph::UEdge sue = INVALID;
+
+  std::vector<SmartBpUGraph::Node> sanv;
+  for (int i = 0; i < nn; ++i) {
+    SmartBpUGraph::Node node = source.addANode();
+    sanv.push_back(node);
+    sanm[node] = i * i;
+    snm[node] = i * i + i;
+    if (i == 0) sn = node;
+  }
+
+  std::vector<SmartBpUGraph::Node> sbnv;
+  for (int i = 0; i < nn; ++i) {
+    SmartBpUGraph::Node node = source.addBNode();
+    sbnv.push_back(node);
+    sbnm[node] = i * i - i;
+    snm[node] = i * i + i + 1;
+  }
+
+  for (int i = 0; i < nn; ++i) {
+    for (int j = 0; j < nn; ++j) {
+      SmartBpUGraph::UEdge edge = source.addEdge(sanv[i], sbnv[j]);
+      suem[edge] = i * i + j * j;
+      sem[source.direct(edge, true)] = i + j * j;
+      sem[source.direct(edge, false)] = i * i + j;
+      if (i == 0 && j == 0) se = source.direct(edge, true);
+      if (i == 0 && j == 0) sue = edge;
+    }
+  }
+  
+  ListBpUGraph target;
+  ListBpUGraph::ANodeMap<int> tanm(target);
+  ListBpUGraph::BNodeMap<int> tbnm(target);
+  ListBpUGraph::NodeMap<int> tnm(target);
+  ListBpUGraph::EdgeMap<int> tem(target);
+  ListBpUGraph::UEdgeMap<int> tuem(target);
+  ListBpUGraph::Node tn;
+  ListBpUGraph::Edge te;
+  ListBpUGraph::UEdge tue;
+
+  SmartBpUGraph::ANodeMap<ListBpUGraph::Node> anr(source);
+  SmartBpUGraph::BNodeMap<ListBpUGraph::Node> bnr(source);
+  SmartBpUGraph::NodeMap<ListBpUGraph::Node> nr(source);
+  SmartBpUGraph::EdgeMap<ListBpUGraph::Edge> er(source);
+  SmartBpUGraph::UEdgeMap<ListBpUGraph::UEdge> uer(source);
+
+  ListBpUGraph::ANodeMap<SmartBpUGraph::Node> ancr(target);
+  ListBpUGraph::BNodeMap<SmartBpUGraph::Node> bncr(target);
+  ListBpUGraph::NodeMap<SmartBpUGraph::Node> ncr(target);
+  ListBpUGraph::EdgeMap<SmartBpUGraph::Edge> ecr(target);
+  ListBpUGraph::UEdgeMap<SmartBpUGraph::UEdge> uecr(target);
+
+  BpUGraphCopy<ListBpUGraph, SmartBpUGraph>(target, source).
+    aNodeMap(tanm, sanm).bNodeMap(tbnm, sbnm).nodeMap(tnm, snm).
+    edgeMap(tem, sem).uEdgeMap(tuem, suem).
+    aNodeRef(anr).bNodeRef(bnr).nodeRef(nr).edgeRef(er).uEdgeRef(uer).
+    aNodeCrossRef(ancr).bNodeCrossRef(bncr).nodeCrossRef(ncr).
+    edgeCrossRef(ecr).uEdgeCrossRef(uecr).
+    node(tn, sn).edge(te, se).uEdge(tue, sue).run();
+
+  for (SmartBpUGraph::ANodeIt it(source); it != INVALID; ++it) {
+    check(nr[it] == anr[it], "Wrong copy.");
+    check(ancr[anr[it]] == it, "Wrong copy.");
+    check(sanm[it] == tanm[anr[it]], "Wrong copy.");
+  }
+
+  for (SmartBpUGraph::BNodeIt it(source); it != INVALID; ++it) {
+    check(nr[it] == bnr[it], "Wrong copy.");
+    check(bncr[bnr[it]] == it, "Wrong copy.");
+    check(sbnm[it] == tbnm[bnr[it]], "Wrong copy.");
+  }
+
+  for (SmartBpUGraph::NodeIt it(source); it != INVALID; ++it) {
+    check(ncr[nr[it]] == it, "Wrong copy.");
+    check(snm[it] == tnm[nr[it]], "Wrong copy.");
+  }
+
+  for (SmartBpUGraph::EdgeIt it(source); it != INVALID; ++it) {
+    check(ecr[er[it]] == it, "Wrong copy.");
+    check(sem[it] == tem[er[it]], "Wrong copy.");
+    check(nr[source.source(it)] == 
+                 target.source(er[it]), "Wrong copy.");
+    check(nr[source.target(it)] == 
+                 target.target(er[it]), "Wrong copy.");
+  }
+
+  for (SmartBpUGraph::UEdgeIt it(source); it != INVALID; ++it) {
+    check(uecr[uer[it]] == it, "Wrong copy.");
+    check(suem[it] == tuem[uer[it]], "Wrong copy.");
+    check(nr[source.aNode(it)] == 
+                 target.aNode(uer[it]), "Wrong copy.");
+    check(nr[source.bNode(it)] == 
+                 target.bNode(uer[it]), "Wrong copy.");
+  }
+
+  for (ListBpUGraph::ANodeIt it(target); it != INVALID; ++it) {
+    check(ancr[it] == ncr[it], "Wrong copy.");
+    check(anr[ancr[it]] == it, "Wrong copy.");
+  }
+
+  for (ListBpUGraph::BNodeIt it(target); it != INVALID; ++it) {
+    check(bncr[it] == ncr[it], "Wrong copy.");
+    check(bnr[bncr[it]] == it, "Wrong copy.");
+  }
+
+  for (ListBpUGraph::NodeIt it(target); it != INVALID; ++it) {
+    check(nr[ncr[it]] == it, "Wrong copy.");
+  }
+
+  for (ListBpUGraph::EdgeIt it(target); it != INVALID; ++it) {
+    check(er[ecr[it]] == it, "Wrong copy.");
+  }
+  for (ListBpUGraph::UEdgeIt it(target); it != INVALID; ++it) {
+    check(uer[uecr[it]] == it, "Wrong copy.");
+  }
+  check(tn == nr[sn], "Wrong copy.");
+  check(te == er[se], "Wrong copy.");
+  check(tue == uer[sue], "Wrong copy.");
+}
+
+int main() {
+  graph_copy_test();
+  ugraph_copy_test();
+  bpugraph_copy_test();
+
+  return 0; 
+}