# HG changeset patch
# User Balazs Dezso <deba@inf.elte.hu>
# Date 1215698756 -7200
# Node ID c0e2c043c0603c088da85283d97f8420120eafc4
# Parent  e3aba2c72be4499ade5628680b74f8f5c1ad802d
Porting graph_copy_test.cc from SVN 3498

diff -r e3aba2c72be4 -r c0e2c043c060 test/CMakeLists.txt
--- a/test/CMakeLists.txt	Thu Jul 10 16:03:23 2008 +0200
+++ b/test/CMakeLists.txt	Thu Jul 10 16:05:56 2008 +0200
@@ -10,6 +10,7 @@
   dijkstra_test
   dim_test
   error_test
+  graph_copy_test
   graph_test
   graph_utils_test
   kruskal_test
diff -r e3aba2c72be4 -r c0e2c043c060 test/Makefile.am
--- a/test/Makefile.am	Thu Jul 10 16:03:23 2008 +0200
+++ b/test/Makefile.am	Thu Jul 10 16:05:56 2008 +0200
@@ -15,6 +15,7 @@
 	test/dijkstra_test \
         test/dim_test \
 	test/error_test \
+	test/graph_copy_test \
 	test/graph_test \
 	test/graph_utils_test \
 	test/kruskal_test \
@@ -36,6 +37,7 @@
 test_dijkstra_test_SOURCES = test/dijkstra_test.cc
 test_dim_test_SOURCES = test/dim_test.cc
 test_error_test_SOURCES = test/error_test.cc
+test_graph_copy_test_SOURCES = test/graph_copy_test.cc
 test_graph_test_SOURCES = test/graph_test.cc
 test_graph_utils_test_SOURCES = test/graph_utils_test.cc
 # test_heap_test_SOURCES = test/heap_test.cc
diff -r e3aba2c72be4 -r c0e2c043c060 test/graph_copy_test.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/graph_copy_test.cc	Thu Jul 10 16:05:56 2008 +0200
@@ -0,0 +1,192 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#include <lemon/smart_graph.h>
+#include <lemon/list_graph.h>
+#include <lemon/lgf_reader.h>
+#include <lemon/graph_utils.h>
+#include <lemon/error.h>
+
+#include "test_tools.h"
+
+using namespace std;
+using namespace lemon;
+
+void digraph_copy_test() {
+  const int nn = 10;
+
+  SmartDigraph from;
+  SmartDigraph::NodeMap<int> fnm(from);
+  SmartDigraph::ArcMap<int> fam(from);
+  SmartDigraph::Node fn = INVALID;
+  SmartDigraph::Arc fa = INVALID;
+
+  std::vector<SmartDigraph::Node> fnv;
+  for (int i = 0; i < nn; ++i) {
+    SmartDigraph::Node node = from.addNode();
+    fnv.push_back(node);
+    fnm[node] = i * i;
+    if (i == 0) fn = node;
+  }
+
+  for (int i = 0; i < nn; ++i) {
+    for (int j = 0; j < nn; ++j) {
+      SmartDigraph::Arc arc = from.addArc(fnv[i], fnv[j]);
+      fam[arc] = i + j * j;
+      if (i == 0 && j == 0) fa = arc;
+    }
+  }
+
+  ListDigraph to;
+  ListDigraph::NodeMap<int> tnm(to);
+  ListDigraph::ArcMap<int> tam(to);
+  ListDigraph::Node tn;
+  ListDigraph::Arc ta;
+
+  SmartDigraph::NodeMap<ListDigraph::Node> nr(from);
+  SmartDigraph::ArcMap<ListDigraph::Arc> er(from);
+
+  ListDigraph::NodeMap<SmartDigraph::Node> ncr(to);
+  ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);
+
+  DigraphCopy<ListDigraph, SmartDigraph>(to, from).
+    nodeMap(tnm, fnm).arcMap(tam, fam).
+    nodeRef(nr).arcRef(er).
+    nodeCrossRef(ncr).arcCrossRef(ecr).
+    node(tn, fn).arc(ta, fa).run();
+
+  for (SmartDigraph::NodeIt it(from); it != INVALID; ++it) {
+    check(ncr[nr[it]] == it, "Wrong copy.");
+    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
+  }
+
+  for (SmartDigraph::ArcIt it(from); it != INVALID; ++it) {
+    check(ecr[er[it]] == it, "Wrong copy.");
+    check(fam[it] == tam[er[it]], "Wrong copy.");
+    check(nr[from.source(it)] == to.source(er[it]), "Wrong copy.");
+    check(nr[from.target(it)] == to.target(er[it]), "Wrong copy.");
+  }
+
+  for (ListDigraph::NodeIt it(to); it != INVALID; ++it) {
+    check(nr[ncr[it]] == it, "Wrong copy.");
+  }
+
+  for (ListDigraph::ArcIt it(to); it != INVALID; ++it) {
+    check(er[ecr[it]] == it, "Wrong copy.");
+  }
+  check(tn == nr[fn], "Wrong copy.");
+  check(ta == er[fa], "Wrong copy.");
+}
+
+void graph_copy_test() {
+  const int nn = 10;
+
+  SmartGraph from;
+  SmartGraph::NodeMap<int> fnm(from);
+  SmartGraph::ArcMap<int> fam(from);
+  SmartGraph::EdgeMap<int> fem(from);
+  SmartGraph::Node fn = INVALID;
+  SmartGraph::Arc fa = INVALID;
+  SmartGraph::Edge fe = INVALID;
+
+  std::vector<SmartGraph::Node> fnv;
+  for (int i = 0; i < nn; ++i) {
+    SmartGraph::Node node = from.addNode();
+    fnv.push_back(node);
+    fnm[node] = i * i;
+    if (i == 0) fn = node;
+  }
+
+  for (int i = 0; i < nn; ++i) {
+    for (int j = 0; j < nn; ++j) {
+      SmartGraph::Edge edge = from.addEdge(fnv[i], fnv[j]);
+      fem[edge] = i * i + j * j;
+      fam[from.direct(edge, true)] = i + j * j;
+      fam[from.direct(edge, false)] = i * i + j;
+      if (i == 0 && j == 0) fa = from.direct(edge, true);
+      if (i == 0 && j == 0) fe = edge;
+    }
+  }
+  
+  ListGraph to;
+  ListGraph::NodeMap<int> tnm(to);
+  ListGraph::ArcMap<int> tam(to);
+  ListGraph::EdgeMap<int> tem(to);
+  ListGraph::Node tn;
+  ListGraph::Arc ta;
+  ListGraph::Edge te;
+
+  SmartGraph::NodeMap<ListGraph::Node> nr(from);
+  SmartGraph::ArcMap<ListGraph::Arc> ar(from);
+  SmartGraph::EdgeMap<ListGraph::Edge> er(from);
+
+  ListGraph::NodeMap<SmartGraph::Node> ncr(to);
+  ListGraph::ArcMap<SmartGraph::Arc> acr(to);
+  ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);
+
+  GraphCopy<ListGraph, SmartGraph>(to, from).
+    nodeMap(tnm, fnm).arcMap(tam, fam).edgeMap(tem, fem).
+    nodeRef(nr).arcRef(ar).edgeRef(er).
+    nodeCrossRef(ncr).arcCrossRef(acr).edgeCrossRef(ecr).
+    node(tn, fn).arc(ta, fa).edge(te, fe).run();
+
+  for (SmartGraph::NodeIt it(from); it != INVALID; ++it) {
+    check(ncr[nr[it]] == it, "Wrong copy.");
+    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
+  }
+
+  for (SmartGraph::ArcIt it(from); it != INVALID; ++it) {
+    check(acr[ar[it]] == it, "Wrong copy.");
+    check(fam[it] == tam[ar[it]], "Wrong copy.");
+    check(nr[from.source(it)] == to.source(ar[it]), "Wrong copy.");
+    check(nr[from.target(it)] == to.target(ar[it]), "Wrong copy.");
+  }
+
+  for (SmartGraph::EdgeIt it(from); it != INVALID; ++it) {
+    check(ecr[er[it]] == it, "Wrong copy.");
+    check(fem[it] == tem[er[it]], "Wrong copy.");
+    check(nr[from.u(it)] == to.u(er[it]) || nr[from.u(it)] == to.v(er[it]), 
+	  "Wrong copy.");
+    check(nr[from.v(it)] == to.u(er[it]) || nr[from.v(it)] == to.v(er[it]), 
+	  "Wrong copy.");
+    check((from.u(it) != from.v(it)) == (to.u(er[it]) != to.v(er[it])), 
+	  "Wrong copy.");
+  }
+
+  for (ListGraph::NodeIt it(to); it != INVALID; ++it) {
+    check(nr[ncr[it]] == it, "Wrong copy.");
+  }
+
+  for (ListGraph::ArcIt it(to); it != INVALID; ++it) {
+    check(ar[acr[it]] == it, "Wrong copy.");
+  }
+  for (ListGraph::EdgeIt it(to); it != INVALID; ++it) {
+    check(er[ecr[it]] == it, "Wrong copy.");
+  }
+  check(tn == nr[fn], "Wrong copy.");
+  check(ta == ar[fa], "Wrong copy.");
+  check(te == er[fe], "Wrong copy.");
+}
+
+
+int main() {
+  digraph_copy_test();
+  graph_copy_test();
+
+  return 0; 
+}