Index: test/CMakeLists.txt
===================================================================
--- test/CMakeLists.txt	(revision 327)
+++ test/CMakeLists.txt	(revision 225)
@@ -17,5 +17,4 @@
   kruskal_test
   maps_test
-  max_matching_test
   random_test
   path_test
Index: test/Makefile.am
===================================================================
--- test/Makefile.am	(revision 345)
+++ test/Makefile.am	(revision 228)
@@ -1,5 +1,4 @@
 EXTRA_DIST += \
-	test/CMakeLists.txt \
-        test/min_cost_flow_test.lgf
+	test/CMakeLists.txt
 
 noinst_HEADERS += \
@@ -21,8 +20,6 @@
 	test/kruskal_test \
         test/maps_test \
-	test/max_matching_test \
         test/random_test \
         test/path_test \
-        test/suurballe_test \
         test/test_tools_fail \
         test/test_tools_pass \
@@ -46,7 +43,5 @@
 test_kruskal_test_SOURCES = test/kruskal_test.cc
 test_maps_test_SOURCES = test/maps_test.cc
-test_max_matching_test_SOURCES = test/max_matching_test.cc
 test_path_test_SOURCES = test/path_test.cc
-test_suurballe_test_SOURCES = test/suurballe_test.cc
 test_random_test_SOURCES = test/random_test.cc
 test_test_tools_fail_SOURCES = test/test_tools_fail.cc
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 293)
+++ test/bfs_test.cc	(revision 228)
@@ -55,50 +55,28 @@
   typedef concepts::Digraph Digraph;
   typedef Bfs<Digraph> BType;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
 
   Digraph G;
-  Node s, t;
-  Arc e;
+  Digraph::Node n;
+  Digraph::Arc e;
   int l;
   bool b;
   BType::DistMap d(G);
   BType::PredMap p(G);
-  Path<Digraph> pp;
+  //  BType::PredNodeMap pn(G);
 
-  {
-    BType bfs_test(G);
+  BType bfs_test(G);
 
-    bfs_test.run(s);
-    bfs_test.run(s,t);
-    bfs_test.run();
+  bfs_test.run(n);
 
-    l  = bfs_test.dist(t);
-    e  = bfs_test.predArc(t);
-    s  = bfs_test.predNode(t);
-    b  = bfs_test.reached(t);
-    d  = bfs_test.distMap();
-    p  = bfs_test.predMap();
-    pp = bfs_test.path(t);
-  }
-  {
-    BType
-      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
-      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
-      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
-      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
-      ::SetStandardProcessedMap
-      ::Create bfs_test(G);
+  l  = bfs_test.dist(n);
+  e  = bfs_test.predArc(n);
+  n  = bfs_test.predNode(n);
+  d  = bfs_test.distMap();
 
-    bfs_test.run(s);
-    bfs_test.run(s,t);
-    bfs_test.run();
+  p  = bfs_test.predMap();
+  //  pn = bfs_test.predNodeMap();
+  b  = bfs_test.reached(n);
 
-    l  = bfs_test.dist(t);
-    e  = bfs_test.predArc(t);
-    s  = bfs_test.predNode(t);
-    b  = bfs_test.reached(t);
-    pp = bfs_test.path(t);
-  }
+  Path<Digraph> pp = bfs_test.path(n);
 }
 
@@ -111,28 +89,12 @@
 
   Digraph g;
-  bool b;
-  bfs(g).run(Node());
-  b=bfs(g).run(Node(),Node());
-  bfs(g).run();
+  bfs(g,Node()).run();
+  bfs(g).source(Node()).run();
   bfs(g)
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .predMap(concepts::WriteMap<Node,Arc>())
+    .distMap(concepts::WriteMap<Node,VType>())
     .reachedMap(concepts::ReadWriteMap<Node,bool>())
     .processedMap(concepts::WriteMap<Node,bool>())
     .run(Node());
-  b=bfs(g)
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,VType>())
-    .reachedMap(concepts::ReadWriteMap<Node,bool>())
-    .processedMap(concepts::WriteMap<Node,bool>())
-    .path(concepts::Path<Digraph>())
-    .dist(VType())
-    .run(Node(),Node());
-  bfs(g)
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,VType>())
-    .reachedMap(concepts::ReadWriteMap<Node,bool>())
-    .processedMap(concepts::WriteMap<Node,bool>())
-    .run();
 }
 
@@ -145,5 +107,5 @@
 
   std::istringstream input(test_lgf);
-  digraphReader(G, input).
+  digraphReader(input, G).
     node("source", s).
     node("target", t).
@@ -153,5 +115,5 @@
   bfs_test.run(s);
 
-  check(bfs_test.dist(t)==2,"Bfs found a wrong path.");
+  check(bfs_test.dist(t)==2,"Bfs found a wrong path." << bfs_test.dist(t));
 
   Path<Digraph> p = bfs_test.path(t);
@@ -167,5 +129,5 @@
     check( !bfs_test.reached(u) ||
            (bfs_test.dist(v) <= bfs_test.dist(u)+1),
-           "Wrong output. " << G.id(u) << "->" << G.id(v));
+           "Wrong output." << G.id(v) << ' ' << G.id(u));
   }
 
@@ -179,12 +141,8 @@
         check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
               "Wrong distance. Difference: "
-              << std::abs(bfs_test.dist(v) - bfs_test.dist(u) - 1));
+              << std::abs(bfs_test.dist(v) - bfs_test.dist(u)
+                          - 1));
       }
     }
-  }
-
-  {
-    NullMap<Node,Arc> myPredMap;
-    bfs(G).predMap(myPredMap).run(s);
   }
 }
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 293)
+++ test/dfs_test.cc	(revision 228)
@@ -21,4 +21,5 @@
 #include <lemon/list_graph.h>
 #include <lemon/lgf_reader.h>
+
 #include <lemon/dfs.h>
 #include <lemon/path.h>
@@ -57,50 +58,25 @@
   typedef concepts::Digraph Digraph;
   typedef Dfs<Digraph> DType;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
 
   Digraph G;
-  Node s, t;
-  Arc e;
+  Digraph::Node n;
+  Digraph::Arc e;
   int l;
   bool b;
   DType::DistMap d(G);
   DType::PredMap p(G);
-  Path<Digraph> pp;
 
-  {
-    DType dfs_test(G);
+  DType dfs_test(G);
 
-    dfs_test.run(s);
-    dfs_test.run(s,t);
-    dfs_test.run();
+  dfs_test.run(n);
 
-    l  = dfs_test.dist(t);
-    e  = dfs_test.predArc(t);
-    s  = dfs_test.predNode(t);
-    b  = dfs_test.reached(t);
-    d  = dfs_test.distMap();
-    p  = dfs_test.predMap();
-    pp = dfs_test.path(t);
-  }
-  {
-    DType
-      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
-      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
-      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
-      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
-      ::SetStandardProcessedMap
-      ::Create dfs_test(G);
+  l  = dfs_test.dist(n);
+  e  = dfs_test.predArc(n);
+  n  = dfs_test.predNode(n);
+  d  = dfs_test.distMap();
+  p  = dfs_test.predMap();
+  b  = dfs_test.reached(n);
 
-    dfs_test.run(s);
-    dfs_test.run(s,t);
-    dfs_test.run();
-
-    l  = dfs_test.dist(t);
-    e  = dfs_test.predArc(t);
-    s  = dfs_test.predNode(t);
-    b  = dfs_test.reached(t);
-    pp = dfs_test.path(t);
-  }
+  Path<Digraph> pp = dfs_test.path(n);
 }
 
@@ -113,28 +89,12 @@
 
   Digraph g;
-  bool b;
-  dfs(g).run(Node());
-  b=dfs(g).run(Node(),Node());
-  dfs(g).run();
+  dfs(g,Node()).run();
+  dfs(g).source(Node()).run();
   dfs(g)
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .predMap(concepts::WriteMap<Node,Arc>())
+    .distMap(concepts::WriteMap<Node,VType>())
     .reachedMap(concepts::ReadWriteMap<Node,bool>())
     .processedMap(concepts::WriteMap<Node,bool>())
     .run(Node());
-  b=dfs(g)
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,VType>())
-    .reachedMap(concepts::ReadWriteMap<Node,bool>())
-    .processedMap(concepts::WriteMap<Node,bool>())
-    .path(concepts::Path<Digraph>())
-    .dist(VType())
-    .run(Node(),Node());
-  dfs(g)
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,VType>())
-    .reachedMap(concepts::ReadWriteMap<Node,bool>())
-    .processedMap(concepts::WriteMap<Node,bool>())
-    .run();
 }
 
@@ -147,5 +107,5 @@
 
   std::istringstream input(test_lgf);
-  digraphReader(G, input).
+  digraphReader(input, G).
     node("source", s).
     node("target", t).
@@ -170,12 +130,7 @@
         check(dfs_test.dist(v) - dfs_test.dist(u) == 1,
               "Wrong distance. (" << dfs_test.dist(u) << "->"
-              << dfs_test.dist(v) << ")");
+              <<dfs_test.dist(v) << ')');
       }
     }
-  }
-
-  {
-    NullMap<Node,Arc> myPredMap;
-    dfs(G).predMap(myPredMap).run(s);
   }
 }
Index: test/digraph_test.cc
===================================================================
--- test/digraph_test.cc	(revision 228)
+++ test/digraph_test.cc	(revision 353)
@@ -20,5 +20,5 @@
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
-//#include <lemon/full_graph.h>
+#include <lemon/full_graph.h>
 //#include <lemon/hypercube_graph.h>
 
@@ -80,4 +80,37 @@
 }
 
+void checkFullDigraph(int num) {
+  typedef FullDigraph Digraph;
+  DIGRAPH_TYPEDEFS(Digraph);
+  Digraph G(num);
+
+  checkGraphNodeList(G, num);
+  checkGraphArcList(G, num * num);
+
+  for (NodeIt n(G); n != INVALID; ++n) {
+    checkGraphOutArcList(G, n, num);
+    checkGraphInArcList(G, n, num);
+  }
+
+  checkGraphConArcList(G, num * num);
+
+  checkNodeIds(G);
+  checkArcIds(G);
+  checkGraphNodeMap(G);
+  checkGraphArcMap(G);
+
+  for (int i = 0; i < G.nodeNum(); ++i) {
+    check(G.index(G(i)) == i, "Wrong index");
+  }
+
+  for (NodeIt s(G); s != INVALID; ++s) {
+    for (NodeIt t(G); t != INVALID; ++t) {
+      Arc a = G.arc(s, t);
+      check(G.source(a) == s && G.target(a) == t, "Wrong arc lookup");
+    }
+  }
+
+}
+
 
 void checkConcepts() {
@@ -177,4 +210,7 @@
     checkDigraphValidity<SmartDigraph>();
   }
+  { // Checking FullDigraph
+    checkFullDigraph(8);
+  }
 }
 
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 293)
+++ test/dijkstra_test.cc	(revision 228)
@@ -21,7 +21,7 @@
 #include <lemon/list_graph.h>
 #include <lemon/lgf_reader.h>
+
 #include <lemon/dijkstra.h>
 #include <lemon/path.h>
-#include <lemon/bin_heap.h>
 
 #include "graph_test.h"
@@ -57,52 +57,28 @@
   typedef concepts::ReadMap<Digraph::Arc,VType> LengthMap;
   typedef Dijkstra<Digraph, LengthMap> DType;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
 
   Digraph G;
-  Node s, t;
-  Arc e;
+  Digraph::Node n;
+  Digraph::Arc e;
   VType l;
   bool b;
   DType::DistMap d(G);
   DType::PredMap p(G);
+  //  DType::PredNodeMap pn(G);
   LengthMap length;
-  Path<Digraph> pp;
 
-  {
-    DType dijkstra_test(G,length);
+  DType dijkstra_test(G,length);
 
-    dijkstra_test.run(s);
-    dijkstra_test.run(s,t);
+  dijkstra_test.run(n);
 
-    l  = dijkstra_test.dist(t);
-    e  = dijkstra_test.predArc(t);
-    s  = dijkstra_test.predNode(t);
-    b  = dijkstra_test.reached(t);
-    d  = dijkstra_test.distMap();
-    p  = dijkstra_test.predMap();
-    pp = dijkstra_test.path(t);
-  }
-  {
-    DType
-      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
-      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
-      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
-      ::SetStandardProcessedMap
-      ::SetOperationTraits<DijkstraWidestPathOperationTraits<VType> >
-      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::Create dijkstra_test(G,length);
+  l  = dijkstra_test.dist(n);
+  e  = dijkstra_test.predArc(n);
+  n  = dijkstra_test.predNode(n);
+  d  = dijkstra_test.distMap();
+  p  = dijkstra_test.predMap();
+  //  pn = dijkstra_test.predNodeMap();
+  b  = dijkstra_test.reached(n);
 
-    dijkstra_test.run(s);
-    dijkstra_test.run(s,t);
-
-    l  = dijkstra_test.dist(t);
-    e  = dijkstra_test.predArc(t);
-    s  = dijkstra_test.predNode(t);
-    b  = dijkstra_test.reached(t);
-    pp = dijkstra_test.path(t);
-  }
-
+  Path<Digraph> pp = dijkstra_test.path(n);
 }
 
@@ -116,19 +92,10 @@
 
   Digraph g;
-  bool b;
-  dijkstra(g,LengthMap()).run(Node());
-  b=dijkstra(g,LengthMap()).run(Node(),Node());
+  dijkstra(g,LengthMap(),Node()).run();
+  dijkstra(g,LengthMap()).source(Node()).run();
   dijkstra(g,LengthMap())
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,VType>())
-    .processedMap(concepts::WriteMap<Node,bool>())
+    .predMap(concepts::WriteMap<Node,Arc>())
+    .distMap(concepts::WriteMap<Node,VType>())
     .run(Node());
-  b=dijkstra(g,LengthMap())
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,VType>())
-    .processedMap(concepts::WriteMap<Node,bool>())
-    .path(concepts::Path<Digraph>())
-    .dist(VType())
-    .run(Node(),Node());
 }
 
@@ -143,5 +110,5 @@
 
   std::istringstream input(test_lgf);
-  digraphReader(G, input).
+  digraphReader(input, G).
     arcMap("length", length).
     node("source", s).
@@ -156,5 +123,5 @@
 
   Path<Digraph> p = dijkstra_test.path(t);
-  check(p.length()==3,"path() found a wrong path.");
+  check(p.length()==3,"getPath() found a wrong path.");
   check(checkPath(G, p),"path() found a wrong path.");
   check(pathSource(G, p) == s,"path() found a wrong path.");
@@ -166,5 +133,5 @@
     check( !dijkstra_test.reached(u) ||
            (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= length[e]),
-           "Wrong output. dist(target)-dist(source)-arc_length=" <<
+           "dist(target)-dist(source)-arc_length= " <<
            dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]);
   }
Index: test/dim_test.cc
===================================================================
--- test/dim_test.cc	(revision 253)
+++ test/dim_test.cc	(revision 242)
@@ -51,36 +51,36 @@
   check(p.x==1 && p.y==2, "Wrong dim2::Point division by a scalar.");
 
-  typedef dim2::Box<int> Box;
-  Box box1;
-  check(box1.empty(), "Wrong empty() in dim2::Box.");
+  typedef dim2::BoundingBox<int> BB;
+  BB box1;
+  check(box1.empty(), "Wrong empty() in dim2::BoundingBox.");
 
   box1.add(a);
-  check(!box1.empty(), "Wrong empty() in dim2::Box.");
+  check(!box1.empty(), "Wrong empty() in dim2::BoundingBox.");
   box1.add(b);
 
   check(box1.left()==1 && box1.bottom()==2 &&
         box1.right()==3 && box1.top()==4,
-        "Wrong addition of points to dim2::Box.");
+        "Wrong addition of points to dim2::BoundingBox.");
 
-  check(box1.inside(Point(2,3)), "Wrong inside() in dim2::Box.");
-  check(box1.inside(Point(1,3)), "Wrong inside() in dim2::Box.");
-  check(!box1.inside(Point(0,3)), "Wrong inside() in dim2::Box.");
+  check(box1.inside(Point(2,3)), "Wrong inside() in dim2::BoundingBox.");
+  check(box1.inside(Point(1,3)), "Wrong inside() in dim2::BoundingBox.");
+  check(!box1.inside(Point(0,3)), "Wrong inside() in dim2::BoundingBox.");
 
-  Box box2(Point(2,2));
-  check(!box2.empty(), "Wrong empty() in dim2::Box.");
-
+  BB box2(Point(2,2));
+  check(!box2.empty(), "Wrong empty() in dim2::BoundingBox.");
+  
   box2.bottomLeft(Point(2,0));
   box2.topRight(Point(5,3));
-  Box box3 = box1 & box2;
+  BB box3 = box1 & box2;
   check(!box3.empty() &&
-        box3.left()==2 && box3.bottom()==2 &&
+        box3.left()==2 && box3.bottom()==2 && 
         box3.right()==3 && box3.top()==3,
-        "Wrong intersection of two dim2::Box objects.");
-
+        "Wrong intersection of two dim2::BoundingBox objects.");
+  
   box1.add(box2);
   check(!box1.empty() &&
         box1.left()==1 && box1.bottom()==0 &&
         box1.right()==5 && box1.top()==4,
-        "Wrong addition of two dim2::Box objects.");
+        "Wrong addition of two dim2::BoundingBox objects.");
 
   return 0;
Index: test/error_test.cc
===================================================================
--- test/error_test.cc	(revision 277)
+++ test/error_test.cc	(revision 223)
@@ -48,7 +48,12 @@
 }
 
+void fixme_disable() {
+  LEMON_FIXME("fixme_disable() is fixme!");
+}
+
 void check_assertion_disable() {
   no_assertion_text_disable();
   assertion_text_disable();
+  fixme_disable();
 }
 #undef LEMON_DISABLE_ASSERTS
@@ -74,8 +79,13 @@
 }
 
+void fixme_custom() {
+  LEMON_FIXME("fixme_custom() is fixme!");
+}
+
 void check_assertion_custom() {
   no_assertion_text_custom();
   assertion_text_custom();
-  check(cnt == 1, "The custom assert handler does not work");
+  fixme_custom();
+  check(cnt == 2, "The custom assert handler does not work");
 }
 
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 282)
+++ test/graph_copy_test.cc	(revision 220)
@@ -64,9 +64,9 @@
   ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);
 
-  digraphCopy(from, to).
-    nodeMap(fnm, tnm).arcMap(fam, tam).
+  DigraphCopy<ListDigraph, SmartDigraph>(to, from).
+    nodeMap(tnm, fnm).arcMap(tam, fam).
     nodeRef(nr).arcRef(er).
     nodeCrossRef(ncr).arcCrossRef(ecr).
-    node(fn, tn).arc(fa, ta).run();
+    node(tn, fn).arc(ta, fa).run();
 
   for (SmartDigraph::NodeIt it(from); it != INVALID; ++it) {
@@ -139,9 +139,9 @@
   ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);
 
-  graphCopy(from, to).
-    nodeMap(fnm, tnm).arcMap(fam, tam).edgeMap(fem, tem).
+  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(fn, tn).arc(fa, ta).edge(fe, te).run();
+    node(tn, fn).arc(ta, fa).edge(te, fe).run();
 
   for (SmartGraph::NodeIt it(from); it != INVALID; ++it) {
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 336)
+++ test/graph_test.cc	(revision 353)
@@ -20,6 +20,6 @@
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
-// #include <lemon/full_graph.h>
-#include <lemon/grid_graph.h>
+#include <lemon/full_graph.h>
+// #include <lemon/grid_graph.h>
 
 #include "test_tools.h"
@@ -96,4 +96,51 @@
 }
 
+void checkFullGraph(int num) {
+  typedef FullGraph Graph;
+  GRAPH_TYPEDEFS(Graph);
+
+  Graph G(num);
+  checkGraphNodeList(G, num);
+  checkGraphEdgeList(G, num * (num - 1) / 2);
+
+  for (NodeIt n(G); n != INVALID; ++n) {
+    checkGraphOutArcList(G, n, num - 1);    
+    checkGraphInArcList(G, n, num - 1);    
+    checkGraphIncEdgeList(G, n, num - 1);    
+  }
+
+  checkGraphConArcList(G, num * (num - 1));
+  checkGraphConEdgeList(G, num * (num - 1) / 2);
+
+  checkArcDirections(G);
+
+  checkNodeIds(G);
+  checkArcIds(G);
+  checkEdgeIds(G);
+  checkGraphNodeMap(G);
+  checkGraphArcMap(G);
+  checkGraphEdgeMap(G);
+
+  
+  for (int i = 0; i < G.nodeNum(); ++i) {
+    check(G.index(G(i)) == i, "Wrong index");
+  }
+
+  for (NodeIt u(G); u != INVALID; ++u) {
+    for (NodeIt v(G); v != INVALID; ++v) {
+      Edge e = G.edge(u, v);
+      Arc a = G.arc(u, v);
+      if (u == v) {
+        check(e == INVALID, "Wrong edge lookup");
+        check(a == INVALID, "Wrong arc lookup");
+      } else {
+        check((G.u(e) == u && G.v(e) == v) ||
+              (G.u(e) == v && G.v(e) == u), "Wrong edge lookup");
+        check(G.source(a) == u && G.target(a) == v, "Wrong arc lookup");
+      }
+    }
+  }
+}
+
 void checkConcepts() {
   { // Checking graph components
@@ -125,11 +172,10 @@
     checkConcept<ClearableGraphComponent<>, SmartGraph>();
   }
-//  { // Checking FullGraph
-//    checkConcept<Graph, FullGraph>();
-//    checkGraphIterators<FullGraph>();
-//  }
-  { // Checking GridGraph
-    checkConcept<Graph, GridGraph>();
-  }
+  { // Checking FullGraph
+    checkConcept<Graph, FullGraph>();
+  }
+//   { // Checking GridGraph
+//     checkConcept<Graph, GridGraph>();
+//   }
 }
 
@@ -188,82 +234,47 @@
 }
 
-void checkGridGraph(int width, int height) {
-  typedef GridGraph Graph;
-  GRAPH_TYPEDEFS(Graph);
-  Graph G(width, height);
-
-  check(G.width() == width, "Wrong column number");
-  check(G.height() == height, "Wrong row number");
-
-  for (int i = 0; i < width; ++i) {
-    for (int j = 0; j < height; ++j) {
-      check(G.col(G(i, j)) == i, "Wrong column");
-      check(G.row(G(i, j)) == j, "Wrong row");
-      check(G.pos(G(i, j)).x == i, "Wrong column");
-      check(G.pos(G(i, j)).y == j, "Wrong row");
-    }
-  }
-
-  for (int j = 0; j < height; ++j) {
-    for (int i = 0; i < width - 1; ++i) {
-      check(G.source(G.right(G(i, j))) == G(i, j), "Wrong right");
-      check(G.target(G.right(G(i, j))) == G(i + 1, j), "Wrong right");
-    }
-    check(G.right(G(width - 1, j)) == INVALID, "Wrong right");
-  }
-
-  for (int j = 0; j < height; ++j) {
-    for (int i = 1; i < width; ++i) {
-      check(G.source(G.left(G(i, j))) == G(i, j), "Wrong left");
-      check(G.target(G.left(G(i, j))) == G(i - 1, j), "Wrong left");
-    }
-    check(G.left(G(0, j)) == INVALID, "Wrong left");
-  }
-
-  for (int i = 0; i < width; ++i) {
-    for (int j = 0; j < height - 1; ++j) {
-      check(G.source(G.up(G(i, j))) == G(i, j), "Wrong up");
-      check(G.target(G.up(G(i, j))) == G(i, j + 1), "Wrong up");
-    }
-    check(G.up(G(i, height - 1)) == INVALID, "Wrong up");
-  }
-
-  for (int i = 0; i < width; ++i) {
-    for (int j = 1; j < height; ++j) {
-      check(G.source(G.down(G(i, j))) == G(i, j), "Wrong down");
-      check(G.target(G.down(G(i, j))) == G(i, j - 1), "Wrong down");
-    }
-    check(G.down(G(i, 0)) == INVALID, "Wrong down");
-  }
-
-  checkGraphNodeList(G, width * height);
-  checkGraphEdgeList(G, width * (height - 1) + (width - 1) * height);
-  checkGraphArcList(G, 2 * (width * (height - 1) + (width - 1) * height));
-
-  for (NodeIt n(G); n != INVALID; ++n) {
-    int nb = 4;
-    if (G.col(n) == 0) --nb;
-    if (G.col(n) == width - 1) --nb;
-    if (G.row(n) == 0) --nb;
-    if (G.row(n) == height - 1) --nb;
-
-    checkGraphOutArcList(G, n, nb);
-    checkGraphInArcList(G, n, nb);
-    checkGraphIncEdgeList(G, n, nb);
-  }
-
-  checkArcDirections(G);
-
-  checkGraphConArcList(G, 2 * (width * (height - 1) + (width - 1) * height));
-  checkGraphConEdgeList(G, width * (height - 1) + (width - 1) * height);
-
-  checkNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-  checkGraphNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-
-}
+// void checkGridGraph(const GridGraph& g, int w, int h) {
+//   check(g.width() == w, "Wrong width");
+//   check(g.height() == h, "Wrong height");
+
+//   for (int i = 0; i < w; ++i) {
+//     for (int j = 0; j < h; ++j) {
+//       check(g.col(g(i, j)) == i, "Wrong col");
+//       check(g.row(g(i, j)) == j, "Wrong row");
+//     }
+//   }
+
+//   for (int i = 0; i < w; ++i) {
+//     for (int j = 0; j < h - 1; ++j) {
+//       check(g.source(g.down(g(i, j))) == g(i, j), "Wrong down");
+//       check(g.target(g.down(g(i, j))) == g(i, j + 1), "Wrong down");
+//     }
+//     check(g.down(g(i, h - 1)) == INVALID, "Wrong down");
+//   }
+
+//   for (int i = 0; i < w; ++i) {
+//     for (int j = 1; j < h; ++j) {
+//       check(g.source(g.up(g(i, j))) == g(i, j), "Wrong up");
+//       check(g.target(g.up(g(i, j))) == g(i, j - 1), "Wrong up");
+//     }
+//     check(g.up(g(i, 0)) == INVALID, "Wrong up");
+//   }
+
+//   for (int j = 0; j < h; ++j) {
+//     for (int i = 0; i < w - 1; ++i) {
+//       check(g.source(g.right(g(i, j))) == g(i, j), "Wrong right");
+//       check(g.target(g.right(g(i, j))) == g(i + 1, j), "Wrong right");
+//     }
+//     check(g.right(g(w - 1, j)) == INVALID, "Wrong right");
+//   }
+
+//   for (int j = 0; j < h; ++j) {
+//     for (int i = 1; i < w; ++i) {
+//       check(g.source(g.left(g(i, j))) == g(i, j), "Wrong left");
+//       check(g.target(g.left(g(i, j))) == g(i - 1, j), "Wrong left");
+//     }
+//     check(g.left(g(0, j)) == INVALID, "Wrong left");
+//   }
+// }
 
 void checkGraphs() {
@@ -276,16 +287,14 @@
     checkGraphValidity<SmartGraph>();
   }
-//   { // Checking FullGraph
-//     FullGraph g(5);
-//     checkGraphNodeList(g, 5);
-//     checkGraphEdgeList(g, 10);
-//   }
-  { // Checking GridGraph
-    checkGridGraph(5, 8);
-    checkGridGraph(8, 5);
-    checkGridGraph(5, 5);
-    checkGridGraph(0, 0);
-    checkGridGraph(1, 1);
-  }
+  { // Checking FullGraph   
+    checkFullGraph(7);
+    checkFullGraph(8);
+  }
+//   { // Checking GridGraph
+//     GridGraph g(5, 6);
+//     checkGraphNodeList(g, 30);
+//     checkGraphEdgeList(g, 49);
+//     checkGridGraph(g, 5, 6);
+//   }
 }
 
Index: test/graph_test.h
===================================================================
--- test/graph_test.h	(revision 263)
+++ test/graph_test.h	(revision 228)
@@ -213,8 +213,8 @@
     check(s == 0, "Wrong sum.");
 
-    // map = constMap<Node>(12);
-    // for (NodeIt it(G); it != INVALID; ++it) {
-    //   check(map[it] == 12, "Wrong operator[].");
-    // }
+    map = constMap<Node>(12);
+    for (NodeIt it(G); it != INVALID; ++it) {
+      check(map[it] == 12, "Wrong operator[].");
+    }
   }
 
@@ -243,8 +243,8 @@
     check(s == 0, "Wrong sum.");
 
-    // map = constMap<Arc>(12);
-    // for (ArcIt it(G); it != INVALID; ++it) {
-    //   check(map[it] == 12, "Wrong operator[].");
-    // }
+    map = constMap<Arc>(12);
+    for (ArcIt it(G); it != INVALID; ++it) {
+      check(map[it] == 12, "Wrong operator[].");
+    }
   }
 
@@ -273,8 +273,8 @@
     check(s == 0, "Wrong sum.");
 
-    // map = constMap<Edge>(12);
-    // for (EdgeIt it(G); it != INVALID; ++it) {
-    //   check(map[it] == 12, "Wrong operator[].");
-    // }
+    map = constMap<Edge>(12);
+    for (EdgeIt it(G); it != INVALID; ++it) {
+      check(map[it] == 12, "Wrong operator[].");
+    }
   }
 
Index: test/heap_test.cc
===================================================================
--- test/heap_test.cc	(revision 293)
+++ test/heap_test.cc	(revision 212)
@@ -132,5 +132,5 @@
                       Node source) {
 
-  typename Dijkstra<Digraph, IntArcMap>::template SetStandardHeap<Heap>::
+  typename Dijkstra<Digraph, IntArcMap>::template DefStandardHeap<Heap>::
     Create dijkstra(digraph, length);
 
@@ -168,5 +168,5 @@
 
   std::istringstream input(test_lgf);
-  digraphReader(digraph, input).
+  digraphReader(input, digraph).
     arcMap("capacity", length).
     node("source", source).
Index: test/max_matching_test.cc
===================================================================
--- test/max_matching_test.cc	(revision 327)
+++ 	(revision )
@@ -1,310 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * 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 <iostream>
-#include <sstream>
-#include <vector>
-#include <queue>
-#include <lemon/math.h>
-#include <cstdlib>
-
-#include <lemon/max_matching.h>
-#include <lemon/smart_graph.h>
-#include <lemon/lgf_reader.h>
-
-#include "test_tools.h"
-
-using namespace std;
-using namespace lemon;
-
-GRAPH_TYPEDEFS(SmartGraph);
-
-
-const int lgfn = 3;
-const std::string lgf[lgfn] = {
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "7 4  0      984\n"
-  "0 7  1      73\n"
-  "7 1  2      204\n"
-  "2 3  3      583\n"
-  "2 7  4      565\n"
-  "2 1  5      582\n"
-  "0 4  6      551\n"
-  "2 5  7      385\n"
-  "1 5  8      561\n"
-  "5 3  9      484\n"
-  "7 5  10     904\n"
-  "3 6  11     47\n"
-  "7 6  12     888\n"
-  "3 0  13     747\n"
-  "6 1  14     310\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "2 5  0      710\n"
-  "0 5  1      241\n"
-  "2 4  2      856\n"
-  "2 6  3      762\n"
-  "4 1  4      747\n"
-  "6 1  5      962\n"
-  "4 7  6      723\n"
-  "1 7  7      661\n"
-  "2 3  8      376\n"
-  "1 0  9      416\n"
-  "6 7  10     391\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "6 2  0      553\n"
-  "0 7  1      653\n"
-  "6 3  2      22\n"
-  "4 7  3      846\n"
-  "7 2  4      981\n"
-  "7 6  5      250\n"
-  "5 2  6      539\n",
-};
-
-void checkMatching(const SmartGraph& graph,
-                   const MaxMatching<SmartGraph>& mm) {
-  int num = 0;
-
-  IntNodeMap comp_index(graph);
-  UnionFind<IntNodeMap> comp(comp_index);
-
-  int barrier_num = 0;
-
-  for (NodeIt n(graph); n != INVALID; ++n) {
-    check(mm.decomposition(n) == MaxMatching<SmartGraph>::EVEN ||
-          mm.matching(n) != INVALID, "Wrong Gallai-Edmonds decomposition");
-    if (mm.decomposition(n) == MaxMatching<SmartGraph>::ODD) {
-      ++barrier_num;
-    } else {
-      comp.insert(n);
-    }
-  }
-
-  for (EdgeIt e(graph); e != INVALID; ++e) {
-    if (mm.matching(e)) {
-      check(e == mm.matching(graph.u(e)), "Wrong matching");
-      check(e == mm.matching(graph.v(e)), "Wrong matching");
-      ++num;
-    }
-    check(mm.decomposition(graph.u(e)) != MaxMatching<SmartGraph>::EVEN ||
-          mm.decomposition(graph.v(e)) != MaxMatching<SmartGraph>::MATCHED,
-          "Wrong Gallai-Edmonds decomposition");
-
-    check(mm.decomposition(graph.v(e)) != MaxMatching<SmartGraph>::EVEN ||
-          mm.decomposition(graph.u(e)) != MaxMatching<SmartGraph>::MATCHED,
-          "Wrong Gallai-Edmonds decomposition");
-
-    if (mm.decomposition(graph.u(e)) != MaxMatching<SmartGraph>::ODD &&
-        mm.decomposition(graph.v(e)) != MaxMatching<SmartGraph>::ODD) {
-      comp.join(graph.u(e), graph.v(e));
-    }
-  }
-
-  std::set<int> comp_root;
-  int odd_comp_num = 0;
-  for (NodeIt n(graph); n != INVALID; ++n) {
-    if (mm.decomposition(n) != MaxMatching<SmartGraph>::ODD) {
-      int root = comp.find(n);
-      if (comp_root.find(root) == comp_root.end()) {
-        comp_root.insert(root);
-        if (comp.size(n) % 2 == 1) {
-          ++odd_comp_num;
-        }
-      }
-    }
-  }
-
-  check(mm.matchingSize() == num, "Wrong matching");
-  check(2 * num == countNodes(graph) - (odd_comp_num - barrier_num),
-         "Wrong matching");
-  return;
-}
-
-void checkWeightedMatching(const SmartGraph& graph,
-                   const SmartGraph::EdgeMap<int>& weight,
-                   const MaxWeightedMatching<SmartGraph>& mwm) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e)) continue;
-    int rw = mwm.nodeValue(graph.u(e)) + mwm.nodeValue(graph.v(e));
-
-    for (int i = 0; i < mwm.blossomNum(); ++i) {
-      bool s = false, t = false;
-      for (MaxWeightedMatching<SmartGraph>::BlossomIt n(mwm, i);
-           n != INVALID; ++n) {
-        if (graph.u(e) == n) s = true;
-        if (graph.v(e) == n) t = true;
-      }
-      if (s == true && t == true) {
-        rw += mwm.blossomValue(i);
-      }
-    }
-    rw -= weight[e] * mwm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (mwm.matching(n) != INVALID) {
-      check(mwm.nodeValue(n) >= 0, "Invalid node value");
-      pv += weight[mwm.matching(n)];
-      SmartGraph::Node o = graph.target(mwm.matching(n));
-      check(mwm.mate(n) == o, "Invalid matching");
-      check(mwm.matching(n) == graph.oppositeArc(mwm.matching(o)),
-            "Invalid matching");
-    } else {
-      check(mwm.mate(n) == INVALID, "Invalid matching");
-      check(mwm.nodeValue(n) == 0, "Invalid matching");
-    }
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwm.nodeValue(n);
-  }
-
-  for (int i = 0; i < mwm.blossomNum(); ++i) {
-    check(mwm.blossomValue(i) >= 0, "Invalid blossom value");
-    check(mwm.blossomSize(i) % 2 == 1, "Even blossom size");
-    dv += mwm.blossomValue(i) * ((mwm.blossomSize(i) - 1) / 2);
-  }
-
-  check(pv * mwm.dualScale == dv * 2, "Wrong duality");
-
-  return;
-}
-
-void checkWeightedPerfectMatching(const SmartGraph& graph,
-                          const SmartGraph::EdgeMap<int>& weight,
-                          const MaxWeightedPerfectMatching<SmartGraph>& mwpm) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e)) continue;
-    int rw = mwpm.nodeValue(graph.u(e)) + mwpm.nodeValue(graph.v(e));
-
-    for (int i = 0; i < mwpm.blossomNum(); ++i) {
-      bool s = false, t = false;
-      for (MaxWeightedPerfectMatching<SmartGraph>::BlossomIt n(mwpm, i);
-           n != INVALID; ++n) {
-        if (graph.u(e) == n) s = true;
-        if (graph.v(e) == n) t = true;
-      }
-      if (s == true && t == true) {
-        rw += mwpm.blossomValue(i);
-      }
-    }
-    rw -= weight[e] * mwpm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwpm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    check(mwpm.matching(n) != INVALID, "Non perfect");
-    pv += weight[mwpm.matching(n)];
-    SmartGraph::Node o = graph.target(mwpm.matching(n));
-    check(mwpm.mate(n) == o, "Invalid matching");
-    check(mwpm.matching(n) == graph.oppositeArc(mwpm.matching(o)),
-          "Invalid matching");
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwpm.nodeValue(n);
-  }
-
-  for (int i = 0; i < mwpm.blossomNum(); ++i) {
-    check(mwpm.blossomValue(i) >= 0, "Invalid blossom value");
-    check(mwpm.blossomSize(i) % 2 == 1, "Even blossom size");
-    dv += mwpm.blossomValue(i) * ((mwpm.blossomSize(i) - 1) / 2);
-  }
-
-  check(pv * mwpm.dualScale == dv * 2, "Wrong duality");
-
-  return;
-}
-
-
-int main() {
-
-  for (int i = 0; i < lgfn; ++i) {
-    SmartGraph graph;
-    SmartGraph::EdgeMap<int> weight(graph);
-
-    istringstream lgfs(lgf[i]);
-    graphReader(graph, lgfs).
-      edgeMap("weight", weight).run();
-
-    MaxMatching<SmartGraph> mm(graph);
-    mm.run();
-    checkMatching(graph, mm);
-
-    MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-    mwm.run();
-    checkWeightedMatching(graph, weight, mwm);
-
-    MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-    bool perfect = mwpm.run();
-
-    check(perfect == (mm.matchingSize() * 2 == countNodes(graph)),
-          "Perfect matching found");
-
-    if (perfect) {
-      checkWeightedPerfectMatching(graph, weight, mwpm);
-    }
-  }
-
-  return 0;
-}
Index: test/min_cost_flow_test.lgf
===================================================================
--- test/min_cost_flow_test.lgf	(revision 345)
+++ 	(revision )
@@ -1,44 +1,0 @@
-@nodes
-label	supply1	supply2	supply3
-1	0	20	27	
-2	0	-4	0		
-3	0	0	0	
-4	0	0	0	
-5	0	9	0	
-6	0	-6	0	
-7	0	0	0	
-8	0	0	0	
-9	0	3	0	
-10	0	-2	0	
-11	0	0	0		
-12	0	-20	-27	
-               
-@arcs
-		cost	capacity	lower1	lower2
-1	2	70	11		0	8
-1	3	150	3		0	1
-1	4	80	15		0	2
-2	8	80	12		0	0
-3	5	140	5		0	3
-4	6	60	10		0	1
-4	7	80	2		0	0
-4	8	110	3		0	0
-5	7	60	14		0	0
-5	11	120	12		0	0
-6	3	0	3		0	0
-6	9	140	4		0	0
-6	10	90	8		0	0
-7	1	30	5		0	0
-8	12	60	16		0	4
-9	12	50	6		0	0
-10	12	70	13		0	5
-10	2	100	7		0	0
-10	7	60	10		0	0
-11	10	20	14		0	6
-12	11	30	10		0	0
-
-@attributes
-source	1
-target	12
-
-@end
Index: test/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 346)
+++ 	(revision )
@@ -1,160 +1,0 @@
-/* -*- 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 <iostream>
-#include <fstream>
-
-#include <lemon/list_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/path.h>
-#include <lemon/suurballe.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-// Check the feasibility of the flow
-template <typename Digraph, typename FlowMap>
-bool checkFlow( const Digraph& gr, const FlowMap& flow, 
-                typename Digraph::Node s, typename Digraph::Node t,
-                int value )
-{
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  for (ArcIt e(gr); e != INVALID; ++e)
-    if (!(flow[e] == 0 || flow[e] == 1)) return false;
-
-  for (NodeIt n(gr); n != INVALID; ++n) {
-    int sum = 0;
-    for (OutArcIt e(gr, n); e != INVALID; ++e)
-      sum += flow[e];
-    for (InArcIt e(gr, n); e != INVALID; ++e)
-      sum -= flow[e];
-    if (n == s && sum != value) return false;
-    if (n == t && sum != -value) return false;
-    if (n != s && n != t && sum != 0) return false;
-  }
-
-  return true;
-}
-
-// Check the optimalitiy of the flow
-template < typename Digraph, typename CostMap, 
-           typename FlowMap, typename PotentialMap >
-bool checkOptimality( const Digraph& gr, const CostMap& cost,
-                      const FlowMap& flow, const PotentialMap& pi )
-{
-  // Check the "Complementary Slackness" optimality condition
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  bool opt = true;
-  for (ArcIt e(gr); e != INVALID; ++e) {
-    typename CostMap::Value red_cost =
-      cost[e] + pi[gr.source(e)] - pi[gr.target(e)];
-    opt = (flow[e] == 0 && red_cost >= 0) ||
-          (flow[e] == 1 && red_cost <= 0);
-    if (!opt) break;
-  }
-  return opt;
-}
-
-// Check a path
-template <typename Digraph, typename Path>
-bool checkPath( const Digraph& gr, const Path& path,
-                typename Digraph::Node s, typename Digraph::Node t)
-{
-  // Check the "Complementary Slackness" optimality condition
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  Node n = s;
-  for (int i = 0; i < path.length(); ++i) {
-    if (gr.source(path.nth(i)) != n) return false;
-    n = gr.target(path.nth(i));
-  }
-  return n == t;
-}
-
-
-int main()
-{
-  DIGRAPH_TYPEDEFS(ListDigraph);
-
-  // Read the test digraph
-  ListDigraph digraph;
-  ListDigraph::ArcMap<int> length(digraph);
-  Node source, target;
-
-  std::string fname;
-  if(getenv("srcdir"))
-    fname = std::string(getenv("srcdir"));
-  else fname = ".";
-  fname += "/test/min_cost_flow_test.lgf";
-
-  std::ifstream input(fname.c_str());
-  check(input, "Input file '" << fname << "' not found");
-  DigraphReader<ListDigraph>(digraph, input).
-    arcMap("cost", length).
-    node("source", source).
-    node("target", target).
-    run();
-  input.close();
-  
-  // Find 2 paths
-  {
-    Suurballe<ListDigraph> suurballe(digraph, length, source, target);
-    check(suurballe.run(2) == 2, "Wrong number of paths");
-    check(checkFlow(digraph, suurballe.flowMap(), source, target, 2),
-          "The flow is not feasible");
-    check(suurballe.totalLength() == 510, "The flow is not optimal");
-    check(checkOptimality(digraph, length, suurballe.flowMap(), 
-                          suurballe.potentialMap()),
-          "Wrong potentials");
-    for (int i = 0; i < suurballe.pathNum(); ++i)
-      check(checkPath(digraph, suurballe.path(i), source, target),
-            "Wrong path");
-  }
-
-  // Find 3 paths
-  {
-    Suurballe<ListDigraph> suurballe(digraph, length, source, target);
-    check(suurballe.run(3) == 3, "Wrong number of paths");
-    check(checkFlow(digraph, suurballe.flowMap(), source, target, 3),
-          "The flow is not feasible");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-    check(checkOptimality(digraph, length, suurballe.flowMap(), 
-                          suurballe.potentialMap()),
-          "Wrong potentials");
-    for (int i = 0; i < suurballe.pathNum(); ++i)
-      check(checkPath(digraph, suurballe.path(i), source, target),
-            "Wrong path");
-  }
-
-  // Find 5 paths (only 3 can be found)
-  {
-    Suurballe<ListDigraph> suurballe(digraph, length, source, target);
-    check(suurballe.run(5) == 3, "Wrong number of paths");
-    check(checkFlow(digraph, suurballe.flowMap(), source, target, 3),
-          "The flow is not feasible");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-    check(checkOptimality(digraph, length, suurballe.flowMap(), 
-                          suurballe.potentialMap()),
-          "Wrong potentials");
-    for (int i = 0; i < suurballe.pathNum(); ++i)
-      check(checkPath(digraph, suurballe.path(i), source, target),
-            "Wrong path");
-  }
-
-  return 0;
-}
