Index: test/CMakeLists.txt
===================================================================
--- test/CMakeLists.txt	(revision 944)
+++ test/CMakeLists.txt	(revision 950)
@@ -14,5 +14,4 @@
 SET(TESTS
   adaptors_test
-  bellman_ford_test
   bfs_test
   circulation_test
@@ -26,5 +25,4 @@
   error_test
   euler_test
-  fractional_matching_test
   gomory_hu_test
   graph_copy_test
@@ -39,7 +37,5 @@
   min_cost_arborescence_test
   min_cost_flow_test
-  min_mean_cycle_test
   path_test
-  planarity_test
   preflow_test
   radix_sort_test
@@ -87,5 +83,5 @@
     GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
     ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
+      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex.dll ${TARGET_PATH}
     )
   ENDIF()
@@ -129,5 +125,5 @@
     GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
     ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
+      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex.dll ${TARGET_PATH}
     )
   ENDIF()
Index: test/Makefile.am
===================================================================
--- test/Makefile.am	(revision 944)
+++ test/Makefile.am	(revision 937)
@@ -1,6 +1,2 @@
-if USE_VALGRIND
-TESTS_ENVIRONMENT=$(top_srcdir)/scripts/valgrind-wrapper.sh
-endif
-
 EXTRA_DIST += \
 	test/CMakeLists.txt
@@ -12,5 +8,4 @@
 check_PROGRAMS += \
 	test/adaptors_test \
-	test/bellman_ford_test \
 	test/bfs_test \
 	test/circulation_test \
@@ -24,5 +19,4 @@
 	test/error_test \
 	test/euler_test \
-	test/fractional_matching_test \
 	test/gomory_hu_test \
 	test/graph_copy_test \
@@ -37,7 +31,5 @@
 	test/min_cost_arborescence_test \
 	test/min_cost_flow_test \
-	test/min_mean_cycle_test \
 	test/path_test \
-	test/planarity_test \
 	test/preflow_test \
 	test/radix_sort_test \
@@ -62,5 +54,4 @@
 
 test_adaptors_test_SOURCES = test/adaptors_test.cc
-test_bellman_ford_test_SOURCES = test/bellman_ford_test.cc
 test_bfs_test_SOURCES = test/bfs_test.cc
 test_circulation_test_SOURCES = test/circulation_test.cc
@@ -74,12 +65,11 @@
 test_error_test_SOURCES = test/error_test.cc
 test_euler_test_SOURCES = test/euler_test.cc
-test_fractional_matching_test_SOURCES = test/fractional_matching_test.cc
 test_gomory_hu_test_SOURCES = test/gomory_hu_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_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
 test_heap_test_SOURCES = test/heap_test.cc
 test_kruskal_test_SOURCES = test/kruskal_test.cc
+test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
 test_lgf_test_SOURCES = test/lgf_test.cc
 test_lp_test_SOURCES = test/lp_test.cc
@@ -89,7 +79,5 @@
 test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc
 test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc
-test_min_mean_cycle_test_SOURCES = test/min_mean_cycle_test.cc
 test_path_test_SOURCES = test/path_test.cc
-test_planarity_test_SOURCES = test/planarity_test.cc
 test_preflow_test_SOURCES = test/preflow_test.cc
 test_radix_sort_test_SOURCES = test/radix_sort_test.cc
Index: test/adaptors_test.cc
===================================================================
--- test/adaptors_test.cc	(revision 504)
+++ test/adaptors_test.cc	(revision 465)
@@ -1372,18 +1372,26 @@
 
   GridGraph::EdgeMap<bool> dir_map(graph);
-  dir_map[graph.right(n1)] = graph.u(graph.right(n1)) != n1;
-  dir_map[graph.up(n1)] = graph.u(graph.up(n1)) == n1;
-  dir_map[graph.left(n4)] = graph.u(graph.left(n4)) == n4;
-  dir_map[graph.down(n4)] = graph.u(graph.down(n4)) == n4;
+  dir_map[graph.right(n1)] = graph.u(graph.right(n1)) == n1;
+  dir_map[graph.up(n1)] = graph.u(graph.up(n1)) != n1;
+  dir_map[graph.left(n4)] = graph.u(graph.left(n4)) != n4;
+  dir_map[graph.down(n4)] = graph.u(graph.down(n4)) != n4;
 
   // Apply several adaptors on the grid graph
-  typedef SplitNodes<Orienter< const GridGraph, GridGraph::EdgeMap<bool> > >
-    SplitGridGraph;
+  typedef SplitNodes< ReverseDigraph< const Orienter<
+            const GridGraph, GridGraph::EdgeMap<bool> > > >
+    RevSplitGridGraph;
+  typedef ReverseDigraph<const RevSplitGridGraph> SplitGridGraph;
   typedef Undirector<const SplitGridGraph> USplitGridGraph;
+  typedef Undirector<const USplitGridGraph> UUSplitGridGraph;
+  checkConcept<concepts::Digraph, RevSplitGridGraph>();
   checkConcept<concepts::Digraph, SplitGridGraph>();
   checkConcept<concepts::Graph, USplitGridGraph>();
-
-  SplitGridGraph adaptor = splitNodes(orienter(graph, dir_map));
+  checkConcept<concepts::Graph, UUSplitGridGraph>();
+
+  RevSplitGridGraph rev_adaptor =
+    splitNodes(reverseDigraph(orienter(graph, dir_map)));
+  SplitGridGraph adaptor = reverseDigraph(rev_adaptor);
   USplitGridGraph uadaptor = undirector(adaptor);
+  UUSplitGridGraph uuadaptor = undirector(uadaptor);
 
   // Check adaptor
@@ -1392,21 +1400,21 @@
   checkGraphConArcList(adaptor, 8);
 
-  checkGraphOutArcList(adaptor, adaptor.inNode(n1), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n1), 1);
-  checkGraphOutArcList(adaptor, adaptor.inNode(n2), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n2), 0);
-  checkGraphOutArcList(adaptor, adaptor.inNode(n3), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n3), 1);
-  checkGraphOutArcList(adaptor, adaptor.inNode(n4), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n4), 2);
-
-  checkGraphInArcList(adaptor, adaptor.inNode(n1), 1);
-  checkGraphInArcList(adaptor, adaptor.outNode(n1), 1);
-  checkGraphInArcList(adaptor, adaptor.inNode(n2), 2);
-  checkGraphInArcList(adaptor, adaptor.outNode(n2), 1);
-  checkGraphInArcList(adaptor, adaptor.inNode(n3), 1);
-  checkGraphInArcList(adaptor, adaptor.outNode(n3), 1);
-  checkGraphInArcList(adaptor, adaptor.inNode(n4), 0);
-  checkGraphInArcList(adaptor, adaptor.outNode(n4), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.inNode(n1), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.outNode(n1), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.inNode(n2), 2);
+  checkGraphOutArcList(adaptor, rev_adaptor.outNode(n2), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.inNode(n3), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.outNode(n3), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.inNode(n4), 0);
+  checkGraphOutArcList(adaptor, rev_adaptor.outNode(n4), 1);
+
+  checkGraphInArcList(adaptor, rev_adaptor.inNode(n1), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.outNode(n1), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.inNode(n2), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.outNode(n2), 0);
+  checkGraphInArcList(adaptor, rev_adaptor.inNode(n3), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.outNode(n3), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.inNode(n4), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.outNode(n4), 2);
 
   checkNodeIds(adaptor);
@@ -1431,12 +1439,27 @@
   checkGraphArcMap(uadaptor);
 
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n1), 2);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n1), 2);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n2), 3);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n2), 1);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n3), 2);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n3), 2);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n4), 1);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n4), 3);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n1), 2);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n1), 2);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n2), 3);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n2), 1);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n3), 2);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n3), 2);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n4), 1);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n4), 3);
+
+  // Check uuadaptor
+  checkGraphNodeList(uuadaptor, 8);
+  checkGraphEdgeList(uuadaptor, 16);
+  checkGraphArcList(uuadaptor, 32);
+  checkGraphConEdgeList(uuadaptor, 16);
+  checkGraphConArcList(uuadaptor, 32);
+
+  checkNodeIds(uuadaptor);
+  checkEdgeIds(uuadaptor);
+  checkArcIds(uuadaptor);
+
+  checkGraphNodeMap(uuadaptor);
+  checkGraphEdgeMap(uuadaptor);
+  checkGraphArcMap(uuadaptor);
 }
 
Index: test/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 881)
+++ 	(revision )
@@ -1,285 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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/concepts/digraph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/list_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/bellman_ford.h>
-#include <lemon/path.h>
-
-#include "graph_test.h"
-#include "test_tools.h"
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "@arcs\n"
-  "    length\n"
-  "0 1 3\n"
-  "1 2 -3\n"
-  "1 2 -5\n"
-  "1 3 -2\n"
-  "0 2 -1\n"
-  "1 2 -4\n"
-  "0 3 2\n"
-  "4 2 -5\n"
-  "2 3 1\n"
-  "@attributes\n"
-  "source 0\n"
-  "target 3\n";
-
-
-void checkBellmanFordCompile()
-{
-  typedef int Value;
-  typedef concepts::Digraph Digraph;
-  typedef concepts::ReadMap<Digraph::Arc,Value> LengthMap;
-  typedef BellmanFord<Digraph, LengthMap> BF;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-
-  Digraph gr;
-  Node s, t, n;
-  Arc e;
-  Value l;
-  int k=3;
-  bool b;
-  BF::DistMap d(gr);
-  BF::PredMap p(gr);
-  LengthMap length;
-  concepts::Path<Digraph> pp;
-
-  {
-    BF bf_test(gr,length);
-    const BF& const_bf_test = bf_test;
-
-    bf_test.run(s);
-    bf_test.run(s,k);
-
-    bf_test.init();
-    bf_test.addSource(s);
-    bf_test.addSource(s, 1);
-    b = bf_test.processNextRound();
-    b = bf_test.processNextWeakRound();
-
-    bf_test.start();
-    bf_test.checkedStart();
-    bf_test.limitedStart(k);
-
-    l  = const_bf_test.dist(t);
-    e  = const_bf_test.predArc(t);
-    s  = const_bf_test.predNode(t);
-    b  = const_bf_test.reached(t);
-    d  = const_bf_test.distMap();
-    p  = const_bf_test.predMap();
-    pp = const_bf_test.path(t);
-    pp = const_bf_test.negativeCycle();
-
-    for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
-  }
-  {
-    BF::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
-      ::SetDistMap<concepts::ReadWriteMap<Node,Value> >
-      ::SetOperationTraits<BellmanFordDefaultOperationTraits<Value> >
-      ::Create bf_test(gr,length);
-
-    LengthMap length_map;
-    concepts::ReadWriteMap<Node,Arc> pred_map;
-    concepts::ReadWriteMap<Node,Value> dist_map;
-
-    bf_test
-      .lengthMap(length_map)
-      .predMap(pred_map)
-      .distMap(dist_map);
-
-    bf_test.run(s);
-    bf_test.run(s,k);
-
-    bf_test.init();
-    bf_test.addSource(s);
-    bf_test.addSource(s, 1);
-    b = bf_test.processNextRound();
-    b = bf_test.processNextWeakRound();
-
-    bf_test.start();
-    bf_test.checkedStart();
-    bf_test.limitedStart(k);
-
-    l  = bf_test.dist(t);
-    e  = bf_test.predArc(t);
-    s  = bf_test.predNode(t);
-    b  = bf_test.reached(t);
-    pp = bf_test.path(t);
-    pp = bf_test.negativeCycle();
-  }
-}
-
-void checkBellmanFordFunctionCompile()
-{
-  typedef int Value;
-  typedef concepts::Digraph Digraph;
-  typedef Digraph::Arc Arc;
-  typedef Digraph::Node Node;
-  typedef concepts::ReadMap<Digraph::Arc,Value> LengthMap;
-
-  Digraph g;
-  bool b;
-  bellmanFord(g,LengthMap()).run(Node());
-  b = bellmanFord(g,LengthMap()).run(Node(),Node());
-  bellmanFord(g,LengthMap())
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,Value>())
-    .run(Node());
-  b=bellmanFord(g,LengthMap())
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,Value>())
-    .path(concepts::Path<Digraph>())
-    .dist(Value())
-    .run(Node(),Node());
-}
-
-
-template <typename Digraph, typename Value>
-void checkBellmanFord() {
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  typedef typename Digraph::template ArcMap<Value> LengthMap;
-
-  Digraph gr;
-  Node s, t;
-  LengthMap length(gr);
-
-  std::istringstream input(test_lgf);
-  digraphReader(gr, input).
-    arcMap("length", length).
-    node("source", s).
-    node("target", t).
-    run();
-
-  BellmanFord<Digraph, LengthMap>
-    bf(gr, length);
-  bf.run(s);
-  Path<Digraph> p = bf.path(t);
-
-  check(bf.reached(t) && bf.dist(t) == -1, "Bellman-Ford found a wrong path.");
-  check(p.length() == 3, "path() found a wrong path.");
-  check(checkPath(gr, p), "path() found a wrong path.");
-  check(pathSource(gr, p) == s, "path() found a wrong path.");
-  check(pathTarget(gr, p) == t, "path() found a wrong path.");
-
-  ListPath<Digraph> path;
-  Value dist;
-  bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t);
-
-  check(reached && dist == -1, "Bellman-Ford found a wrong path.");
-  check(path.length() == 3, "path() found a wrong path.");
-  check(checkPath(gr, path), "path() found a wrong path.");
-  check(pathSource(gr, path) == s, "path() found a wrong path.");
-  check(pathTarget(gr, path) == t, "path() found a wrong path.");
-
-  for(ArcIt e(gr); e!=INVALID; ++e) {
-    Node u=gr.source(e);
-    Node v=gr.target(e);
-    check(!bf.reached(u) || (bf.dist(v) - bf.dist(u) <= length[e]),
-          "Wrong output. dist(target)-dist(source)-arc_length=" <<
-          bf.dist(v) - bf.dist(u) - length[e]);
-  }
-
-  for(NodeIt v(gr); v!=INVALID; ++v) {
-    if (bf.reached(v)) {
-      check(v==s || bf.predArc(v)!=INVALID, "Wrong tree.");
-      if (bf.predArc(v)!=INVALID ) {
-        Arc e=bf.predArc(v);
-        Node u=gr.source(e);
-        check(u==bf.predNode(v),"Wrong tree.");
-        check(bf.dist(v) - bf.dist(u) == length[e],
-              "Wrong distance! Difference: " <<
-              bf.dist(v) - bf.dist(u) - length[e]);
-      }
-    }
-  }
-}
-
-void checkBellmanFordNegativeCycle() {
-  DIGRAPH_TYPEDEFS(SmartDigraph);
-
-  SmartDigraph gr;
-  IntArcMap length(gr);
-
-  Node n1 = gr.addNode();
-  Node n2 = gr.addNode();
-  Node n3 = gr.addNode();
-  Node n4 = gr.addNode();
-
-  Arc a1 = gr.addArc(n1, n2);
-  Arc a2 = gr.addArc(n2, n2);
-
-  length[a1] = 2;
-  length[a2] = -1;
-
-  {
-    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
-    bf.run(n1);
-    StaticPath<SmartDigraph> p = bf.negativeCycle();
-    check(p.length() == 1 && p.front() == p.back() && p.front() == a2,
-          "Wrong negative cycle.");
-  }
-
-  length[a2] = 0;
-
-  {
-    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
-    bf.run(n1);
-    check(bf.negativeCycle().empty(),
-          "Negative cycle should not be found.");
-  }
-
-  length[gr.addArc(n1, n3)] = 5;
-  length[gr.addArc(n4, n3)] = 1;
-  length[gr.addArc(n2, n4)] = 2;
-  length[gr.addArc(n3, n2)] = -4;
-
-  {
-    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
-    bf.init();
-    bf.addSource(n1);
-    for (int i = 0; i < 4; ++i) {
-      check(bf.negativeCycle().empty(),
-            "Negative cycle should not be found.");
-      bf.processNextRound();
-    }
-    StaticPath<SmartDigraph> p = bf.negativeCycle();
-    check(p.length() == 3, "Wrong negative cycle.");
-    check(length[p.nth(0)] + length[p.nth(1)] + length[p.nth(2)] == -1,
-          "Wrong negative cycle.");
-  }
-}
-
-int main() {
-  checkBellmanFord<ListDigraph, int>();
-  checkBellmanFord<SmartDigraph, double>();
-  checkBellmanFordNegativeCycle();
-  return 0;
-}
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 877)
+++ test/bfs_test.cc	(revision 585)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -84,5 +84,5 @@
     b = const_bfs_test.emptyQueue();
     i = const_bfs_test.queueSize();
-
+    
     bfs_test.start();
     bfs_test.start(t);
@@ -105,10 +105,10 @@
       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::Create bfs_test(G);
-
+      
     concepts::ReadWriteMap<Node,Arc> pred_map;
     concepts::ReadWriteMap<Node,int> dist_map;
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-
+    
     bfs_test
       .predMap(pred_map)
@@ -120,5 +120,5 @@
     bfs_test.run(s,t);
     bfs_test.run();
-
+    
     bfs_test.init();
     bfs_test.addSource(s);
@@ -129,5 +129,5 @@
     b = bfs_test.emptyQueue();
     i = bfs_test.queueSize();
-
+    
     bfs_test.start();
     bfs_test.start(t);
Index: test/circulation_test.cc
===================================================================
--- test/circulation_test.cc	(revision 877)
+++ test/circulation_test.cc	(revision 611)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -82,5 +82,5 @@
   CirculationType circ_test(g, lcap, ucap, supply);
   const CirculationType& const_circ_test = circ_test;
-
+   
   circ_test
     .lowerMap(lcap)
@@ -88,9 +88,4 @@
     .supplyMap(supply)
     .flowMap(flow);
-
-  const CirculationType::Elevator& elev = const_circ_test.elevator();
-  circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
-  CirculationType::Tolerance tol = const_circ_test.tolerance();
-  circ_test.tolerance(tol);
 
   circ_test.init();
@@ -103,5 +98,5 @@
   b = const_circ_test.barrier(n);
   const_circ_test.barrierMap(bar);
-
+  
   ignore_unused_variable_warning(fm);
 }
Index: test/connectivity_test.cc
===================================================================
--- test/connectivity_test.cc	(revision 877)
+++ test/connectivity_test.cc	(revision 649)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,10 +30,10 @@
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Digraph::NodeMap<int> order(d);
-    Graph g(d);
-
+  
+  {
+    Digraph d;
+    Digraph::NodeMap<int> order(d);
+    Graph g(d);
+    
     check(stronglyConnected(d), "The empty digraph is strongly connected");
     check(countStronglyConnectedComponents(d) == 0,
@@ -49,5 +49,5 @@
     check(countBiEdgeConnectedComponents(g) == 0,
           "The empty graph has 0 bi-edge-connected component");
-
+          
     check(dag(d), "The empty digraph is DAG.");
     check(checkedTopologicalSort(d, order), "The empty digraph is DAG.");
@@ -83,5 +83,5 @@
     check(countBiEdgeConnectedComponents(g) == 1,
           "This graph has 1 bi-edge-connected component");
-
+          
     check(dag(d), "This digraph is DAG.");
     check(checkedTopologicalSort(d, order), "This digraph is DAG.");
@@ -102,5 +102,5 @@
     Digraph::NodeMap<int> order(d);
     Graph g(d);
-
+    
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -109,5 +109,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-
+    
     d.addArc(n1, n3);
     d.addArc(n3, n2);
@@ -137,21 +137,21 @@
     check(!parallelFree(g), "This graph is not parallel-free.");
     check(!simpleGraph(g), "This graph is not simple.");
-
+    
     d.addArc(n3, n3);
-
+    
     check(!loopFree(d), "This digraph is not loop-free.");
     check(!loopFree(g), "This graph is not loop-free.");
     check(!simpleGraph(d), "This digraph is not simple.");
-
+    
     d.addArc(n3, n2);
-
+    
     check(!parallelFree(d), "This digraph is not parallel-free.");
   }
-
+  
   {
     Digraph d;
     Digraph::ArcMap<bool> cutarcs(d, false);
     Graph g(d);
-
+    
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -173,5 +173,5 @@
     d.addArc(n6, n7);
     d.addArc(n7, n6);
-
+   
     check(!stronglyConnected(d), "This digraph is not strongly connected");
     check(countStronglyConnectedComponents(d) == 3,
@@ -236,5 +236,5 @@
     Digraph d;
     Digraph::NodeMap<int> order(d);
-
+    
     Digraph::Node belt = d.addNode();
     Digraph::Node trousers = d.addNode();
@@ -256,5 +256,5 @@
     d.addArc(shirt, necktie);
     d.addArc(necktie, coat);
-
+    
     check(dag(d), "This digraph is DAG.");
     topologicalSort(d, order);
@@ -268,5 +268,5 @@
     ListGraph g;
     ListGraph::NodeMap<bool> map(g);
-
+    
     ListGraph::Node n1 = g.addNode();
     ListGraph::Node n2 = g.addNode();
@@ -284,8 +284,8 @@
     g.addEdge(n4, n7);
     g.addEdge(n5, n7);
-
+   
     check(bipartite(g), "This graph is bipartite");
     check(bipartitePartitions(g, map), "This graph is bipartite");
-
+    
     check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7],
           "Wrong bipartitePartitions()");
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 944)
+++ test/dfs_test.cc	(revision 937)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -87,5 +87,5 @@
     b = const_dfs_test.emptyQueue();
     i = const_dfs_test.queueSize();
-
+    
     dfs_test.start();
     dfs_test.start(t);
@@ -113,5 +113,5 @@
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-
+    
     dfs_test
       .predMap(pred_map)
@@ -130,5 +130,5 @@
     b = dfs_test.emptyQueue();
     i = dfs_test.queueSize();
-
+    
     dfs_test.start();
     dfs_test.start(t);
@@ -220,5 +220,5 @@
   check(dfs.run(s1,t1) && dfs.reached(t1),"Node 3 is reachable from Node 6.");
   }
-
+  
   {
     NullMap<Node,Arc> myPredMap;
Index: test/digraph_test.cc
===================================================================
--- test/digraph_test.cc	(revision 877)
+++ test/digraph_test.cc	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -20,5 +20,4 @@
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
-#include <lemon/static_graph.h>
 #include <lemon/full_graph.h>
 
@@ -36,7 +35,4 @@
   checkGraphNodeList(G, 0);
   checkGraphArcList(G, 0);
-
-  G.reserveNode(3);
-  G.reserveArc(4);
 
   Node
@@ -288,12 +284,4 @@
 
   snapshot.restore();
-  snapshot.save(G);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 4);
-
-  G.addArc(G.addNode(), G.addNode());
-
-  snapshot.restore();
 
   checkGraphNodeList(G, 4);
@@ -330,8 +318,4 @@
     checkConcept<ClearableDigraphComponent<>, SmartDigraph>();
   }
-  { // Checking StaticDigraph
-    checkConcept<Digraph, StaticDigraph>();
-    checkConcept<ClearableDigraphComponent<>, StaticDigraph>();
-  }
   { // Checking FullDigraph
     checkConcept<Digraph, FullDigraph>();
@@ -389,120 +373,8 @@
 }
 
-void checkStaticDigraph() {
-  SmartDigraph g;
-  SmartDigraph::NodeMap<StaticDigraph::Node> nref(g);
-  SmartDigraph::ArcMap<StaticDigraph::Arc> aref(g);
-
-  StaticDigraph G;
-
-  checkGraphNodeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  G.build(g, nref, aref);
-
-  checkGraphNodeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  SmartDigraph::Node
-    n1 = g.addNode(),
-    n2 = g.addNode(),
-    n3 = g.addNode();
-
-  G.build(g, nref, aref);
-
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 0);
-
-  SmartDigraph::Arc a1 = g.addArc(n1, n2);
-
-  G.build(g, nref, aref);
-
-  check(G.source(aref[a1]) == nref[n1] && G.target(aref[a1]) == nref[n2],
-        "Wrong arc or wrong references");
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 1);
-
-  checkGraphOutArcList(G, nref[n1], 1);
-  checkGraphOutArcList(G, nref[n2], 0);
-  checkGraphOutArcList(G, nref[n3], 0);
-
-  checkGraphInArcList(G, nref[n1], 0);
-  checkGraphInArcList(G, nref[n2], 1);
-  checkGraphInArcList(G, nref[n3], 0);
-
-  checkGraphConArcList(G, 1);
-
-  SmartDigraph::Arc
-    a2 = g.addArc(n2, n1),
-    a3 = g.addArc(n2, n3),
-    a4 = g.addArc(n2, n3);
-
-  digraphCopy(g, G).nodeRef(nref).run();
-
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 4);
-
-  checkGraphOutArcList(G, nref[n1], 1);
-  checkGraphOutArcList(G, nref[n2], 3);
-  checkGraphOutArcList(G, nref[n3], 0);
-
-  checkGraphInArcList(G, nref[n1], 1);
-  checkGraphInArcList(G, nref[n2], 1);
-  checkGraphInArcList(G, nref[n3], 2);
-
-  checkGraphConArcList(G, 4);
-
-  std::vector<std::pair<int,int> > arcs;
-  arcs.push_back(std::make_pair(0,1));
-  arcs.push_back(std::make_pair(0,2));
-  arcs.push_back(std::make_pair(1,3));
-  arcs.push_back(std::make_pair(1,2));
-  arcs.push_back(std::make_pair(3,0));
-  arcs.push_back(std::make_pair(3,3));
-  arcs.push_back(std::make_pair(4,2));
-  arcs.push_back(std::make_pair(4,3));
-  arcs.push_back(std::make_pair(4,1));
-
-  G.build(6, arcs.begin(), arcs.end());
-
-  checkGraphNodeList(G, 6);
-  checkGraphArcList(G, 9);
-
-  checkGraphOutArcList(G, G.node(0), 2);
-  checkGraphOutArcList(G, G.node(1), 2);
-  checkGraphOutArcList(G, G.node(2), 0);
-  checkGraphOutArcList(G, G.node(3), 2);
-  checkGraphOutArcList(G, G.node(4), 3);
-  checkGraphOutArcList(G, G.node(5), 0);
-
-  checkGraphInArcList(G, G.node(0), 1);
-  checkGraphInArcList(G, G.node(1), 2);
-  checkGraphInArcList(G, G.node(2), 3);
-  checkGraphInArcList(G, G.node(3), 3);
-  checkGraphInArcList(G, G.node(4), 0);
-  checkGraphInArcList(G, G.node(5), 0);
-
-  checkGraphConArcList(G, 9);
-
-  checkNodeIds(G);
-  checkArcIds(G);
-  checkGraphNodeMap(G);
-  checkGraphArcMap(G);
-
-  int n = G.nodeNum();
-  int m = G.arcNum();
-  check(G.index(G.node(n-1)) == n-1, "Wrong index.");
-  check(G.index(G.arc(m-1)) == m-1, "Wrong index.");
-}
-
 void checkFullDigraph(int num) {
   typedef FullDigraph Digraph;
   DIGRAPH_TYPEDEFS(Digraph);
-
   Digraph G(num);
-  check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
-
-  G.resize(num);
-  check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
 
   checkGraphNodeList(G, num);
@@ -548,7 +420,4 @@
     checkDigraphValidity<SmartDigraph>();
   }
-  { // Checking StaticDigraph
-    checkStaticDigraph();
-  }
   { // Checking FullDigraph
     checkFullDigraph(8);
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 877)
+++ test/dijkstra_test.cc	(revision 585)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -86,5 +86,5 @@
     b = const_dijkstra_test.emptyQueue();
     i = const_dijkstra_test.queueSize();
-
+    
     dijkstra_test.start();
     dijkstra_test.start(t);
@@ -110,5 +110,5 @@
       ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
       ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
+      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >, 
                 concepts::ReadWriteMap<Node,int> >
       ::Create dijkstra_test(G,length);
@@ -120,5 +120,5 @@
     concepts::ReadWriteMap<Node,int> heap_cross_ref;
     BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
-
+    
     dijkstra_test
       .lengthMap(length_map)
@@ -137,5 +137,5 @@
     b = dijkstra_test.emptyQueue();
     i = dijkstra_test.queueSize();
-
+    
     dijkstra_test.start();
     dijkstra_test.start(t);
Index: test/edge_set_test.cc
===================================================================
--- test/edge_set_test.cc	(revision 877)
+++ test/edge_set_test.cc	(revision 512)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/euler_test.cc
===================================================================
--- test/euler_test.cc	(revision 877)
+++ test/euler_test.cc	(revision 592)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -86,9 +86,9 @@
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Graph g(d);
-
+  
+  {
+    Digraph d;
+    Graph g(d);
+    
     checkDiEulerIt(d);
     checkDiEulerIt(g);
@@ -129,5 +129,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n1);
@@ -154,5 +154,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n4);
@@ -190,5 +190,5 @@
     Digraph::Node n4 = d.addNode();
     Digraph::Node n5 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n3);
@@ -212,5 +212,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n3);
Index: test/fractional_matching_test.cc
===================================================================
--- test/fractional_matching_test.cc	(revision 877)
+++ 	(revision )
@@ -1,525 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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 <cstdlib>
-
-#include <lemon/fractional_matching.h>
-#include <lemon/smart_graph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/math.h>
-
-#include "test_tools.h"
-
-using namespace std;
-using namespace lemon;
-
-GRAPH_TYPEDEFS(SmartGraph);
-
-
-const int lgfn = 4;
-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",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "@edges\n"
-  "     label  weight\n"
-  "0 0  0      100\n"
-};
-
-void checkMaxFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-
-  Graph g;
-  Node n;
-  Edge e;
-
-  MaxFractionalMatching<Graph> mat_test(g);
-  const MaxFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.start(true);
-  mat_test.startPerfect();
-  mat_test.startPerfect(true);
-  mat_test.run();
-  mat_test.run(true);
-  mat_test.runPerfect();
-  mat_test.runPerfect(true);
-
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.barrier(n);
-}
-
-void checkMaxWeightedFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<int> WeightMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  WeightMap w(g);
-
-  MaxWeightedFractionalMatching<Graph> mat_test(g, w);
-  const MaxWeightedFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.run();
-
-  const_mat_test.matchingWeight();
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxWeightedFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-}
-
-void checkMaxWeightedPerfectFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<int> WeightMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  WeightMap w(g);
-
-  MaxWeightedPerfectFractionalMatching<Graph> mat_test(g, w);
-  const MaxWeightedPerfectFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.run();
-
-  const_mat_test.matchingWeight();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxWeightedPerfectFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-}
-
-void checkFractionalMatching(const SmartGraph& graph,
-                             const MaxFractionalMatching<SmartGraph>& mfm,
-                             bool allow_loops = true) {
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    if (mfm.matching(n) != INVALID) {
-      check(indeg == 1, "Invalid matching");
-      ++pv;
-    } else {
-      check(indeg == 0, "Invalid matching");
-    }
-  }
-  check(pv == mfm.matchingSize(), "Wrong matching size");
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
-          mfm.matching(e), "Invalid matching");
-  }
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  int anum = 0, bnum = 0;
-  SmartGraph::NodeMap<bool> neighbours(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (!mfm.barrier(n)) continue;
-    ++anum;
-    for (SmartGraph::InArcIt a(graph, n); a != INVALID; ++a) {
-      Node u = graph.source(a);
-      if (!allow_loops && u == n) continue;
-      if (!neighbours[u]) {
-        neighbours[u] = true;
-        ++bnum;
-      }
-    }
-  }
-  check(anum - bnum + mfm.matchingSize() == countNodes(graph),
-        "Wrong barrier");
-}
-
-void checkPerfectFractionalMatching(const SmartGraph& graph,
-                             const MaxFractionalMatching<SmartGraph>& mfm,
-                             bool perfect, bool allow_loops = true) {
-  if (perfect) {
-    for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-      int indeg = 0;
-      for (InArcIt a(graph, n); a != INVALID; ++a) {
-        if (mfm.matching(graph.source(a)) == a) {
-          ++indeg;
-        }
-      }
-      check(mfm.matching(n) != INVALID, "Invalid matching");
-      check(indeg == 1, "Invalid matching");
-    }
-    for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-      check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
-            (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
-            mfm.matching(e), "Invalid matching");
-    }
-  } else {
-    int anum = 0, bnum = 0;
-    SmartGraph::NodeMap<bool> neighbours(graph, false);
-    for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-      if (!mfm.barrier(n)) continue;
-      ++anum;
-      for (SmartGraph::InArcIt a(graph, n); a != INVALID; ++a) {
-        Node u = graph.source(a);
-        if (!allow_loops && u == n) continue;
-        if (!neighbours[u]) {
-          neighbours[u] = true;
-          ++bnum;
-        }
-      }
-    }
-    check(anum - bnum > 0, "Wrong barrier");
-  }
-}
-
-void checkWeightedFractionalMatching(const SmartGraph& graph,
-                   const SmartGraph::EdgeMap<int>& weight,
-                   const MaxWeightedFractionalMatching<SmartGraph>& mwfm,
-                   bool allow_loops = true) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e) && !allow_loops) continue;
-    int rw = mwfm.nodeValue(graph.u(e)) + mwfm.nodeValue(graph.v(e))
-      - weight[e] * mwfm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwfm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mwfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    check(indeg <= 1, "Invalid matching");
-    if (mwfm.matching(n) != INVALID) {
-      check(mwfm.nodeValue(n) >= 0, "Invalid node value");
-      check(indeg == 1, "Invalid matching");
-      pv += weight[mwfm.matching(n)];
-      SmartGraph::Node o = graph.target(mwfm.matching(n));
-    } else {
-      check(mwfm.nodeValue(n) == 0, "Invalid matching");
-      check(indeg == 0, "Invalid matching");
-    }
-  }
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mwfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mwfm.matching(graph.v(e)) ? 1 : 0) ==
-          mwfm.matching(e), "Invalid matching");
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwfm.nodeValue(n);
-  }
-
-  check(pv * mwfm.dualScale == dv * 2, "Wrong duality");
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mwfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mwfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mwfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  return;
-}
-
-void checkWeightedPerfectFractionalMatching(const SmartGraph& graph,
-                const SmartGraph::EdgeMap<int>& weight,
-                const MaxWeightedPerfectFractionalMatching<SmartGraph>& mwpfm,
-                bool allow_loops = true) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e) && !allow_loops) continue;
-    int rw = mwpfm.nodeValue(graph.u(e)) + mwpfm.nodeValue(graph.v(e))
-      - weight[e] * mwpfm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwpfm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mwpfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    check(mwpfm.matching(n) != INVALID, "Invalid perfect matching");
-    check(indeg == 1, "Invalid perfect matching");
-    pv += weight[mwpfm.matching(n)];
-    SmartGraph::Node o = graph.target(mwpfm.matching(n));
-  }
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mwpfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) ==
-          mwpfm.matching(e), "Invalid matching");
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwpfm.nodeValue(n);
-  }
-
-  check(pv * mwpfm.dualScale == dv * 2, "Wrong duality");
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mwpfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mwpfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mwpfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  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();
-
-    bool perfect_with_loops;
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, true);
-      mfm.run();
-      checkFractionalMatching(graph, mfm, true);
-      perfect_with_loops = mfm.matchingSize() == countNodes(graph);
-    }
-
-    bool perfect_without_loops;
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, false);
-      mfm.run();
-      checkFractionalMatching(graph, mfm, false);
-      perfect_without_loops = mfm.matchingSize() == countNodes(graph);
-    }
-
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, true);
-      bool result = mfm.runPerfect();
-      checkPerfectFractionalMatching(graph, mfm, result, true);
-      check(result == perfect_with_loops, "Wrong perfect matching");
-    }
-
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, false);
-      bool result = mfm.runPerfect();
-      checkPerfectFractionalMatching(graph, mfm, result, false);
-      check(result == perfect_without_loops, "Wrong perfect matching");
-    }
-
-    {
-      MaxWeightedFractionalMatching<SmartGraph> mwfm(graph, weight, true);
-      mwfm.run();
-      checkWeightedFractionalMatching(graph, weight, mwfm, true);
-    }
-
-    {
-      MaxWeightedFractionalMatching<SmartGraph> mwfm(graph, weight, false);
-      mwfm.run();
-      checkWeightedFractionalMatching(graph, weight, mwfm, false);
-    }
-
-    {
-      MaxWeightedPerfectFractionalMatching<SmartGraph> mwpfm(graph, weight,
-                                                             true);
-      bool perfect = mwpfm.run();
-      check(perfect == (mwpfm.matchingSize() == countNodes(graph)),
-            "Perfect matching found");
-      check(perfect == perfect_with_loops, "Wrong perfect matching");
-
-      if (perfect) {
-        checkWeightedPerfectFractionalMatching(graph, weight, mwpfm, true);
-      }
-    }
-
-    {
-      MaxWeightedPerfectFractionalMatching<SmartGraph> mwpfm(graph, weight,
-                                                             false);
-      bool perfect = mwpfm.run();
-      check(perfect == (mwpfm.matchingSize() == countNodes(graph)),
-            "Perfect matching found");
-      check(perfect == perfect_without_loops, "Wrong perfect matching");
-
-      if (perfect) {
-        checkWeightedPerfectFractionalMatching(graph, weight, mwpfm, false);
-      }
-    }
-
-  }
-
-  return 0;
-}
Index: test/gomory_hu_test.cc
===================================================================
--- test/gomory_hu_test.cc	(revision 877)
+++ test/gomory_hu_test.cc	(revision 596)
@@ -1,20 +1,2 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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>
 
@@ -52,5 +34,5 @@
   "source 0\n"
   "target 3\n";
-
+  
 void checkGomoryHuCompile()
 {
@@ -88,5 +70,5 @@
 
 int cutValue(const Graph& graph, const BoolNodeMap& cut,
-             const IntEdgeMap& capacity) {
+	     const IntEdgeMap& capacity) {
 
   int sum = 0;
@@ -126,5 +108,5 @@
       int sum=0;
       for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
-        sum+=capacity[a];
+        sum+=capacity[a]; 
       check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
 
@@ -137,5 +119,5 @@
     }
   }
-
+  
   return 0;
 }
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 927)
+++ test/graph_copy_test.cc	(revision 896)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,5 +71,5 @@
     nodeCrossRef(ncr).arcCrossRef(ecr).
     node(fn, tn).arc(fa, ta).run();
-
+  
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countArcs(from) == countArcs(to), "Wrong copy.");
@@ -99,5 +99,5 @@
   // Test repeated copy
   digraphCopy(from, to).run();
-
+  
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countArcs(from) == countArcs(to), "Wrong copy.");
@@ -201,5 +201,5 @@
   // Test repeated copy
   graphCopy(from, to).run();
-
+  
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countEdges(from) == countEdges(to), "Wrong copy.");
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 877)
+++ test/graph_test.cc	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,7 +39,4 @@
   checkGraphArcList(G, 0);
 
-  G.reserveNode(3);
-  G.reserveEdge(3);
-
   Node
     n1 = G.addNode(),
@@ -260,17 +257,8 @@
 
   snapshot.restore();
-  snapshot.save(G);
 
   checkGraphNodeList(G, 4);
   checkGraphEdgeList(G, 3);
   checkGraphArcList(G, 6);
-
-  G.addEdge(G.addNode(), G.addNode());
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 4);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
 }
 
@@ -280,11 +268,4 @@
 
   Graph G(num);
-  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
-        "Wrong size");
-
-  G.resize(num);
-  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
-        "Wrong size");
-
   checkGraphNodeList(G, num);
   checkGraphEdgeList(G, num * (num - 1) / 2);
@@ -431,8 +412,4 @@
   check(G.height() == height, "Wrong row number");
 
-  G.resize(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) {
@@ -510,9 +487,4 @@
 
   HypercubeGraph G(dim);
-  check(G.dimension() == dim, "Wrong dimension");
-
-  G.resize(dim);
-  check(G.dimension() == dim, "Wrong dimension");
-
   checkGraphNodeList(G, 1 << dim);
   checkGraphEdgeList(G, dim * (1 << (dim-1)));
Index: test/hao_orlin_test.cc
===================================================================
--- test/hao_orlin_test.cc	(revision 877)
+++ test/hao_orlin_test.cc	(revision 597)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -84,5 +84,5 @@
 
 template <typename Graph, typename CapMap, typename CutMap>
-typename CapMap::Value
+typename CapMap::Value 
   cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
 {
@@ -111,5 +111,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
@@ -127,17 +127,17 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
   }
-
+  
   typedef Undirector<SmartDigraph> UGraph;
   UGraph ugraph(graph);
-
+  
   {
     HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap1);
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 2, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap1, cut), "Wrong cut value");
@@ -147,5 +147,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
@@ -155,5 +155,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");
Index: test/heap_test.cc
===================================================================
--- test/heap_test.cc	(revision 927)
+++ test/heap_test.cc	(revision 681)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -26,4 +26,5 @@
 
 #include <lemon/smart_graph.h>
+
 #include <lemon/lgf_reader.h>
 #include <lemon/dijkstra.h>
@@ -31,10 +32,6 @@
 
 #include <lemon/bin_heap.h>
-#include <lemon/quad_heap.h>
-#include <lemon/dheap.h>
 #include <lemon/fib_heap.h>
-#include <lemon/pairing_heap.h>
 #include <lemon/radix_heap.h>
-#include <lemon/binomial_heap.h>
 #include <lemon/bucket_heap.h>
 
@@ -93,7 +90,9 @@
 void heapSortTest() {
   RangeMap<int> map(test_len, -1);
+
   Heap heap(map);
 
   std::vector<int> v(test_len);
+
   for (int i = 0; i < test_len; ++i) {
     v[i] = test_seq[i];
@@ -102,5 +101,5 @@
   std::sort(v.begin(), v.end());
   for (int i = 0; i < test_len; ++i) {
-    check(v[i] == heap.prio(), "Wrong order in heap sort.");
+    check(v[i] == heap.prio() ,"Wrong order in heap sort.");
     heap.pop();
   }
@@ -114,4 +113,5 @@
 
   std::vector<int> v(test_len);
+
   for (int i = 0; i < test_len; ++i) {
     v[i] = test_seq[i];
@@ -124,8 +124,10 @@
   std::sort(v.begin(), v.end());
   for (int i = 0; i < test_len; ++i) {
-    check(v[i] == heap.prio(), "Wrong order in heap increase test.");
+    check(v[i] == heap.prio() ,"Wrong order in heap increase test.");
     heap.pop();
   }
 }
+
+
 
 template <typename Heap>
@@ -143,5 +145,5 @@
     if (dijkstra.reached(s)) {
       check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a],
-             "Error in shortest path tree.");
+             "Error in a shortest path tree!");
     }
   }
@@ -152,5 +154,5 @@
       Node s = digraph.source(a);
       check( dijkstra.dist(n) - dijkstra.dist(s) == length[a],
-             "Error in shortest path tree.");
+             "Error in a shortest path tree!");
     }
   }
@@ -174,5 +176,4 @@
     run();
 
-  // BinHeap
   {
     typedef BinHeap<Prio, ItemIntMap> IntHeap;
@@ -186,29 +187,4 @@
   }
 
-  // QuadHeap
-  {
-    typedef QuadHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef QuadHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // DHeap
-  {
-    typedef DHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef DHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // FibHeap
   {
     typedef FibHeap<Prio, ItemIntMap> IntHeap;
@@ -222,17 +198,4 @@
   }
 
-  // PairingHeap
-  {
-    typedef PairingHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef PairingHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // RadixHeap
   {
     typedef RadixHeap<ItemIntMap> IntHeap;
@@ -246,17 +209,4 @@
   }
 
-  // BinomialHeap
-  {
-    typedef BinomialHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef BinomialHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // BucketHeap, SimpleBucketHeap
   {
     typedef BucketHeap<ItemIntMap> IntHeap;
@@ -268,40 +218,4 @@
     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
     dijkstraHeapTest<NodeHeap>(digraph, length, source);
-
-    typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap;
-    heapSortTest<SimpleIntHeap>();
-  }
-
-  {
-    typedef FibHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef FibHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  {
-    typedef RadixHeap<ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef RadixHeap<IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  {
-    typedef BucketHeap<ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef BucketHeap<IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
   }
 
Index: test/lgf_test.cc
===================================================================
--- test/lgf_test.cc	(revision 935)
+++ test/lgf_test.cc	(revision 930)
@@ -64,8 +64,8 @@
 
 
-int main()
+int main() 
 {
   {
-    ListDigraph d;
+    ListDigraph d; 
     ListDigraph::Node s,t;
     ListDigraph::ArcMap<int> label(d);
@@ -94,5 +94,5 @@
 
   {
-    ListDigraph d;
+    ListDigraph d; 
     std::istringstream input(test_lgf_nomap);
     digraphReader(d, input).
@@ -111,5 +111,5 @@
 
   {
-    ListDigraph d;
+    ListDigraph d; 
     std::istringstream input(test_lgf_bad1);
     bool ok=false;
@@ -118,5 +118,5 @@
         run();
     }
-    catch (FormatError&)
+    catch (FormatError&) 
       {
         ok = true;
@@ -140,5 +140,5 @@
 
   {
-    ListDigraph d;
+    ListDigraph d; 
     std::istringstream input(test_lgf_bad2);
     bool ok=false;
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 935)
+++ test/lp_test.cc	(revision 932)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 927)
+++ test/maps_test.cc	(revision 684)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,8 +24,4 @@
 #include <lemon/maps.h>
 #include <lemon/list_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/adaptors.h>
-#include <lemon/dfs.h>
-#include <algorithm>
 
 #include "test_tools.h"
@@ -39,20 +35,7 @@
 
 class C {
-  int _x;
+  int x;
 public:
-  C(int x) : _x(x) {}
-  int get() const { return _x; }
-};
-inline bool operator<(C c1, C c2) { return c1.get() < c2.get(); }
-inline bool operator==(C c1, C c2) { return c1.get() == c2.get(); }
-
-C createC(int x) { return C(x); }
-
-template <typename T>
-class Less {
-  T _t;
-public:
-  Less(T t): _t(t) {}
-  bool operator()(const T& t) const { return t < _t; }
+  C(int _x) : x(_x) {}
 };
 
@@ -70,12 +53,4 @@
 
 int binc(int a, B) { return a+1; }
-
-template <typename T>
-class Sum {
-  T& _sum;
-public:
-  Sum(T& sum) : _sum(sum) {}
-  void operator()(const T& t) { _sum += t; }
-};
 
 typedef ReadMap<A, double> DoubleMap;
@@ -226,6 +201,5 @@
 
     checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
-    MapToFunctor<ReadMap<A,B> > map =
-      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
+    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
 
     check(functorToMap(&func)[A()] == 3,
@@ -356,8 +330,4 @@
   {
     typedef std::vector<int> vec;
-    checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >();
-    checkConcept<WriteMap<int, bool>,
-                 LoggerBoolMap<std::back_insert_iterator<vec> > >();
-
     vec v1;
     vec v2(10);
@@ -379,208 +349,27 @@
           it != map2.end(); ++it )
       check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
-
+  }
+  
+  // CrossRefMap
+  {
     typedef ListDigraph Graph;
     DIGRAPH_TYPEDEFS(Graph);
+
+    checkConcept<ReadWriteMap<Node, int>,
+                 CrossRefMap<Graph, Node, int> >();
+    
     Graph gr;
-
+    typedef CrossRefMap<Graph, Node, char> CRMap;
+    typedef CRMap::ValueIterator ValueIt;
+    CRMap map(gr);
+    
     Node n0 = gr.addNode();
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-    Node n3 = gr.addNode();
-
-    gr.addArc(n3, n0);
-    gr.addArc(n3, n2);
-    gr.addArc(n0, n2);
-    gr.addArc(n2, n1);
-    gr.addArc(n0, n1);
-
-    {
-      std::vector<Node> v;
-      dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
-
-      check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
-            "Something is wrong with LoggerBoolMap");
-    }
-    {
-      std::vector<Node> v(countNodes(gr));
-      dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
-
-      check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
-            "Something is wrong with LoggerBoolMap");
-    }
-  }
-
-  // IdMap, RangeIdMap
-  {
-    typedef ListDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
-    checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
-    checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
-    checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
-
-    Graph gr;
-    IdMap<Graph, Node> nmap(gr);
-    IdMap<Graph, Arc> amap(gr);
-    RangeIdMap<Graph, Node> nrmap(gr);
-    RangeIdMap<Graph, Arc> armap(gr);
-
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-
-    Arc a0 = gr.addArc(n0, n1);
-    Arc a1 = gr.addArc(n0, n2);
-    Arc a2 = gr.addArc(n2, n1);
-    Arc a3 = gr.addArc(n2, n0);
-
-    check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
-    check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
-    check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
-
-    check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");
-    check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");
-    check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");
-    check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");
-
-    check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
-    check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
-
-    check(nrmap.size() == 3 && armap.size() == 4,
-          "Wrong RangeIdMap::size()");
-
-    check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
-    check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
-    check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
-
-    check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
-    check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
-    check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
-    check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");
-
-    check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
-    check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
-
-    gr.erase(n1);
-
-    if (nrmap[n0] == 1) nrmap.swap(n0, n2);
-    nrmap.swap(n2, n0);
-    if (armap[a1] == 1) armap.swap(a1, a3);
-    armap.swap(a3, a1);
-
-    check(nrmap.size() == 2 && armap.size() == 2,
-          "Wrong RangeIdMap::size()");
-
-    check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
-    check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
-
-    check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
-    check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
-
-    check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
-    check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
-  }
-
-  // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
-  {
-    typedef ListGraph Graph;
-    GRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
-    checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
-    checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
-    checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();
-    checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();
-    checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();
-
-    Graph gr;
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-
-    gr.addEdge(n0,n1);
-    gr.addEdge(n1,n2);
-    gr.addEdge(n0,n2);
-    gr.addEdge(n2,n1);
-    gr.addEdge(n1,n2);
-    gr.addEdge(n0,n1);
-
-    for (EdgeIt e(gr); e != INVALID; ++e) {
-      check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
-      check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
-    }
-
-    check(mapCompare(gr,
-          sourceMap(orienter(gr, constMap<Edge, bool>(true))),
-          targetMap(orienter(gr, constMap<Edge, bool>(false)))),
-          "Wrong SourceMap or TargetMap");
-
-    typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
-    Digraph dgr(gr, constMap<Edge, bool>(true));
-    OutDegMap<Digraph> odm(dgr);
-    InDegMap<Digraph> idm(dgr);
-
-    check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
-    check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
-
-    gr.addEdge(n2, n0);
-
-    check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
-    check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
-  }
-
-  // CrossRefMap
-  {
-    typedef ListDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadWriteMap<Node, int>,
-                 CrossRefMap<Graph, Node, int> >();
-    checkConcept<ReadWriteMap<Node, bool>,
-                 CrossRefMap<Graph, Node, bool> >();
-    checkConcept<ReadWriteMap<Node, double>,
-                 CrossRefMap<Graph, Node, double> >();
-
-    Graph gr;
-    typedef CrossRefMap<Graph, Node, char> CRMap;
-    CRMap map(gr);
-
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-
+    
     map.set(n0, 'A');
     map.set(n1, 'B');
     map.set(n2, 'C');
-
-    check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
-          "Wrong CrossRefMap");
-    check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
-          "Wrong CrossRefMap");
-    check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,
-          "Wrong CrossRefMap");
-    check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
-          "Wrong CrossRefMap::count()");
-
-    CRMap::ValueIt it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
-          it == map.endValue(), "Wrong value iterator");
-
     map.set(n2, 'A');
-
-    check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
-          "Wrong CrossRefMap");
-    check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");
-    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
-    check(map('C') == INVALID && map.inverse()['C'] == INVALID,
-          "Wrong CrossRefMap");
-    check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0,
-          "Wrong CrossRefMap::count()");
-
-    it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' &&
-          it == map.endValue(), "Wrong value iterator");
-
     map.set(n0, 'C');
 
@@ -590,40 +379,4 @@
     check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
     check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
-    check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
-          "Wrong CrossRefMap::count()");
-
-    it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
-          it == map.endValue(), "Wrong value iterator");
-  }
-
-  // CrossRefMap
-  {
-    typedef SmartDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadWriteMap<Node, int>,
-                 CrossRefMap<Graph, Node, int> >();
-
-    Graph gr;
-    typedef CrossRefMap<Graph, Node, char> CRMap;
-    typedef CRMap::ValueIterator ValueIt;
-    CRMap map(gr);
-
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-
-    map.set(n0, 'A');
-    map.set(n1, 'B');
-    map.set(n2, 'C');
-    map.set(n2, 'A');
-    map.set(n0, 'C');
-
-    check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
-          "Wrong CrossRefMap");
-    check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
-    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
-    check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
 
     ValueIt it = map.beginValue();
@@ -632,372 +385,4 @@
   }
 
-  // Iterable bool map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-
-    typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm;
-    checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>();
-
-    const int num = 10;
-    Graph g;
-    Ibm map0(g, true);
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Ibm map1(g, true);
-    int n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)], "Wrong TrueIt");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-    n = 0;
-    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
-        ++n;
-    }
-    check(n == num, "Wrong number");
-    check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt");
-    check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false");
-
-    map1[items[5]] = true;
-
-    n = 0;
-    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
-        ++n;
-    }
-    check(n == num, "Wrong number");
-
-    map1[items[num / 2]] = false;
-    check(map1[items[num / 2]] == false, "Wrong map value");
-
-    n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
-        ++n;
-    }
-    check(n == num - 1, "Wrong number");
-
-    n = 0;
-    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
-        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
-        ++n;
-    }
-    check(n == 1, "Wrong number");
-
-    map1[items[0]] = false;
-    check(map1[items[0]] == false, "Wrong map value");
-
-    map1[items[num - 1]] = false;
-    check(map1[items[num - 1]] == false, "Wrong map value");
-
-    n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
-        ++n;
-    }
-    check(n == num - 3, "Wrong number");
-    check(map1.trueNum() == num - 3, "Wrong number");
-
-    n = 0;
-    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
-        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
-        ++n;
-    }
-    check(n == 3, "Wrong number");
-    check(map1.falseNum() == 3, "Wrong number");
-  }
-
-  // Iterable int map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-    typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim;
-
-    checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>();
-
-    const int num = 10;
-    Graph g;
-    Iim map0(g, 0);
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Iim map1(g);
-    check(map1.size() == 0, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      map1[items[i]] = i;
-    }
-    check(map1.size() == num, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      Iim::ItemIt it(map1, i);
-      check(static_cast<Item>(it) == items[i], "Wrong value");
-      ++it;
-      check(static_cast<Item>(it) == INVALID, "Wrong value");
-    }
-
-    for (int i = 0; i < num; ++i) {
-      map1[items[i]] = i % 2;
-    }
-    check(map1.size() == 2, "Wrong size");
-
-    int n = 0;
-    for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 0, "Wrong value");
-      ++n;
-    }
-    check(n == (num + 1) / 2, "Wrong number");
-
-    for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 1, "Wrong value");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-  }
-
-  // Iterable value map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-    typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm;
-
-    checkConcept<ReadWriteMap<Item, double>, Ivm>();
-
-    const int num = 10;
-    Graph g;
-    Ivm map0(g, 0.0);
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Ivm map1(g, 0.0);
-    check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size");
-    check(*map1.beginValue() == 0.0, "Wrong value");
-
-    for (int i = 0; i < num; ++i) {
-      map1.set(items[i], static_cast<double>(i));
-    }
-    check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      Ivm::ItemIt it(map1, static_cast<double>(i));
-      check(static_cast<Item>(it) == items[i], "Wrong value");
-      ++it;
-      check(static_cast<Item>(it) == INVALID, "Wrong value");
-    }
-
-    for (Ivm::ValueIt vit = map1.beginValue();
-         vit != map1.endValue(); ++vit) {
-      check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit,
-            "Wrong ValueIt");
-    }
-
-    for (int i = 0; i < num; ++i) {
-      map1.set(items[i], static_cast<double>(i % 2));
-    }
-    check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size");
-
-    int n = 0;
-    for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 0.0, "Wrong value");
-      ++n;
-    }
-    check(n == (num + 1) / 2, "Wrong number");
-
-    for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 1.0, "Wrong value");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-  }
-
-  // Graph map utilities:
-  // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
-  // mapFind(), mapFindIf(), mapCount(), mapCountIf()
-  // mapCopy(), mapCompare(), mapFill()
-  {
-    DIGRAPH_TYPEDEFS(SmartDigraph);
-
-    SmartDigraph g;
-    Node n1 = g.addNode();
-    Node n2 = g.addNode();
-    Node n3 = g.addNode();
-
-    SmartDigraph::NodeMap<int> map1(g);
-    SmartDigraph::ArcMap<char> map2(g);
-    ConstMap<Node, A> cmap1 = A();
-    ConstMap<Arc, C> cmap2 = C(0);
-
-    map1[n1] = 10;
-    map1[n2] = 5;
-    map1[n3] = 12;
-
-    // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
-    check(mapMin(g, map1) == n2, "Wrong mapMin()");
-    check(mapMax(g, map1) == n3, "Wrong mapMax()");
-    check(mapMin(g, map1, std::greater<int>()) == n3, "Wrong mapMin()");
-    check(mapMax(g, map1, std::greater<int>()) == n2, "Wrong mapMax()");
-    check(mapMinValue(g, map1) == 5, "Wrong mapMinValue()");
-    check(mapMaxValue(g, map1) == 12, "Wrong mapMaxValue()");
-
-    check(mapMin(g, map2) == INVALID, "Wrong mapMin()");
-    check(mapMax(g, map2) == INVALID, "Wrong mapMax()");
-
-    check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()");
-    check(mapMax(g, cmap2) == INVALID, "Wrong mapMax()");
-
-    Arc a1 = g.addArc(n1, n2);
-    Arc a2 = g.addArc(n1, n3);
-    Arc a3 = g.addArc(n2, n3);
-    Arc a4 = g.addArc(n3, n1);
-
-    map2[a1] = 'b';
-    map2[a2] = 'a';
-    map2[a3] = 'b';
-    map2[a4] = 'c';
-
-    // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
-    check(mapMin(g, map2) == a2, "Wrong mapMin()");
-    check(mapMax(g, map2) == a4, "Wrong mapMax()");
-    check(mapMin(g, map2, std::greater<int>()) == a4, "Wrong mapMin()");
-    check(mapMax(g, map2, std::greater<int>()) == a2, "Wrong mapMax()");
-    check(mapMinValue(g, map2, std::greater<int>()) == 'c',
-          "Wrong mapMinValue()");
-    check(mapMaxValue(g, map2, std::greater<int>()) == 'a',
-          "Wrong mapMaxValue()");
-
-    check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()");
-    check(mapMax(g, cmap2) != INVALID, "Wrong mapMax()");
-    check(mapMaxValue(g, cmap2) == C(0), "Wrong mapMaxValue()");
-
-    check(mapMin(g, composeMap(functorToMap(&createC), map2)) == a2,
-          "Wrong mapMin()");
-    check(mapMax(g, composeMap(functorToMap(&createC), map2)) == a4,
-          "Wrong mapMax()");
-    check(mapMinValue(g, composeMap(functorToMap(&createC), map2)) == C('a'),
-          "Wrong mapMinValue()");
-    check(mapMaxValue(g, composeMap(functorToMap(&createC), map2)) == C('c'),
-          "Wrong mapMaxValue()");
-
-    // mapFind(), mapFindIf()
-    check(mapFind(g, map1, 5) == n2, "Wrong mapFind()");
-    check(mapFind(g, map1, 6) == INVALID, "Wrong mapFind()");
-    check(mapFind(g, map2, 'a') == a2, "Wrong mapFind()");
-    check(mapFind(g, map2, 'e') == INVALID, "Wrong mapFind()");
-    check(mapFind(g, cmap2, C(0)) == ArcIt(g), "Wrong mapFind()");
-    check(mapFind(g, cmap2, C(1)) == INVALID, "Wrong mapFind()");
-
-    check(mapFindIf(g, map1, Less<int>(7)) == n2,
-          "Wrong mapFindIf()");
-    check(mapFindIf(g, map1, Less<int>(5)) == INVALID,
-          "Wrong mapFindIf()");
-    check(mapFindIf(g, map2, Less<char>('d')) == ArcIt(g),
-          "Wrong mapFindIf()");
-    check(mapFindIf(g, map2, Less<char>('a')) == INVALID,
-          "Wrong mapFindIf()");
-
-    // mapCount(), mapCountIf()
-    check(mapCount(g, map1, 5) == 1, "Wrong mapCount()");
-    check(mapCount(g, map1, 6) == 0, "Wrong mapCount()");
-    check(mapCount(g, map2, 'a') == 1, "Wrong mapCount()");
-    check(mapCount(g, map2, 'b') == 2, "Wrong mapCount()");
-    check(mapCount(g, map2, 'e') == 0, "Wrong mapCount()");
-    check(mapCount(g, cmap2, C(0)) == 4, "Wrong mapCount()");
-    check(mapCount(g, cmap2, C(1)) == 0, "Wrong mapCount()");
-
-    check(mapCountIf(g, map1, Less<int>(11)) == 2,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map1, Less<int>(13)) == 3,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map1, Less<int>(5)) == 0,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map2, Less<char>('d')) == 4,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map2, Less<char>('c')) == 3,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map2, Less<char>('a')) == 0,
-          "Wrong mapCountIf()");
-
-    // MapIt, ConstMapIt
-/*
-These tests can be used after applying bugfix #330
-    typedef SmartDigraph::NodeMap<int>::MapIt MapIt;
-    typedef SmartDigraph::NodeMap<int>::ConstMapIt ConstMapIt;
-    check(*std::min_element(MapIt(map1), MapIt(INVALID)) == 5,
-          "Wrong NodeMap<>::MapIt");
-    check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12,
-          "Wrong NodeMap<>::MapIt");
-
-    int sum = 0;
-    std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum));
-    check(sum == 27, "Wrong NodeMap<>::MapIt");
-    std::for_each(ConstMapIt(map1), ConstMapIt(INVALID), Sum<int>(sum));
-    check(sum == 54, "Wrong NodeMap<>::ConstMapIt");
-*/
-
-    // mapCopy(), mapCompare(), mapFill()
-    check(mapCompare(g, map1, map1), "Wrong mapCompare()");
-    check(mapCompare(g, cmap2, cmap2), "Wrong mapCompare()");
-    check(mapCompare(g, map1, shiftMap(map1, 0)), "Wrong mapCompare()");
-    check(mapCompare(g, map2, scaleMap(map2, 1)), "Wrong mapCompare()");
-    check(!mapCompare(g, map1, shiftMap(map1, 1)), "Wrong mapCompare()");
-
-    SmartDigraph::NodeMap<int> map3(g, 0);
-    SmartDigraph::ArcMap<char> map4(g, 'a');
-
-    check(!mapCompare(g, map1, map3), "Wrong mapCompare()");
-    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");
-
-    mapCopy(g, map1, map3);
-    mapCopy(g, map2, map4);
-
-    check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");
-
-    Undirector<SmartDigraph> ug(g);
-    Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x');
-    Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14);
-
-    check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
-    check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
-    check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
-    check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
-
-    mapCopy(g, map2, umap1);
-
-    check(mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
-
-    mapCopy(g, map2, umap1);
-    mapCopy(g, umap1, map2);
-    mapCopy(ug, map2, umap1);
-    mapCopy(ug, umap1, map2);
-
-    check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
-    mapCopy(ug, umap1, umap2);
-    check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
-
-    check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()");
-    mapFill(g, map1, 2);
-    check(mapCompare(g, constMap<Node>(2), map1), "Wrong mapFill()");
-
-    check(!mapCompare(g, map2, constMap<Arc>('z')), "Wrong mapCompare()");
-    mapCopy(g, constMap<Arc>('z'), map2);
-    check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()");
-  }
-
   return 0;
 }
Index: test/matching_test.cc
===================================================================
--- test/matching_test.cc	(revision 877)
+++ test/matching_test.cc	(revision 594)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -135,5 +135,5 @@
   mat_test.startDense();
   mat_test.run();
-
+  
   const_mat_test.matchingSize();
   const_mat_test.matching(e);
@@ -144,5 +144,5 @@
   const_mat_test.mate(n);
 
-  MaxMatching<Graph>::Status stat =
+  MaxMatching<Graph>::Status stat = 
     const_mat_test.status(n);
   const MaxMatching<Graph>::StatusMap& smap =
@@ -171,5 +171,5 @@
   mat_test.start();
   mat_test.run();
-
+  
   const_mat_test.matchingWeight();
   const_mat_test.matchingSize();
@@ -180,5 +180,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-
+  
   int k = 0;
   const_mat_test.dualValue();
@@ -208,5 +208,5 @@
   mat_test.start();
   mat_test.run();
-
+  
   const_mat_test.matchingWeight();
   const_mat_test.matching(e);
@@ -216,5 +216,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-
+  
   int k = 0;
   const_mat_test.dualValue();
@@ -402,44 +402,20 @@
       edgeMap("weight", weight).run();
 
-    bool perfect;
-    {
-      MaxMatching<SmartGraph> mm(graph);
-      mm.run();
-      checkMatching(graph, mm);
-      perfect = 2 * mm.matchingSize() == countNodes(graph);
-    }
-
-    {
-      MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-      mwm.run();
-      checkWeightedMatching(graph, weight, mwm);
-    }
-
-    {
-      MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-      mwm.init();
-      mwm.start();
-      checkWeightedMatching(graph, weight, mwm);
-    }
-
-    {
-      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-      bool result = mwpm.run();
-
-      check(result == perfect, "Perfect matching found");
-      if (perfect) {
-        checkWeightedPerfectMatching(graph, weight, mwpm);
-      }
-    }
-
-    {
-      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-      mwpm.init();
-      bool result = mwpm.start();
-
-      check(result == perfect, "Perfect matching found");
-      if (perfect) {
-        checkWeightedPerfectMatching(graph, weight, mwpm);
-      }
+    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);
     }
   }
Index: test/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 877)
+++ test/min_cost_arborescence_test.cc	(revision 625)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -111,5 +111,5 @@
   b = const_mcarb_test.emptyQueue();
   i = const_mcarb_test.queueSize();
-
+  
   c = const_mcarb_test.arborescenceCost();
   b = const_mcarb_test.arborescence(e);
@@ -121,10 +121,10 @@
   b = const_mcarb_test.reached(n);
   b = const_mcarb_test.processed(n);
-
+  
   i = const_mcarb_test.dualNum();
   c = const_mcarb_test.dualValue();
   i = const_mcarb_test.dualSize(i);
   c = const_mcarb_test.dualValue(i);
-
+  
   ignore_unused_variable_warning(am);
   ignore_unused_variable_warning(pm);
Index: test/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 877)
+++ test/min_cost_flow_test.cc	(revision 669)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -25,10 +25,6 @@
 
 #include <lemon/network_simplex.h>
-#include <lemon/capacity_scaling.h>
-#include <lemon/cost_scaling.h>
-#include <lemon/cycle_canceling.h>
 
 #include <lemon/concepts/digraph.h>
-#include <lemon/concepts/heap.h>
 #include <lemon/concept_check.h>
 
@@ -37,5 +33,4 @@
 using namespace lemon;
 
-// Test networks
 char test_lgf[] =
   "@nodes\n"
@@ -53,5 +48,5 @@
   "   11     0    0    0    0  -10    0\n"
   "   12   -20  -27    0  -30  -30  -20\n"
-  "\n"
+  "\n"                
   "@arcs\n"
   "       cost  cap low1 low2 low3\n"
@@ -82,56 +77,4 @@
   "target 12\n";
 
-char test_neg1_lgf[] =
-  "@nodes\n"
-  "label   sup\n"
-  "    1   100\n"
-  "    2     0\n"
-  "    3     0\n"
-  "    4  -100\n"
-  "    5     0\n"
-  "    6     0\n"
-  "    7     0\n"
-  "@arcs\n"
-  "      cost   low1   low2\n"
-  "1 2    100      0      0\n"
-  "1 3     30      0      0\n"
-  "2 4     20      0      0\n"
-  "3 4     80      0      0\n"
-  "3 2     50      0      0\n"
-  "5 3     10      0      0\n"
-  "5 6     80      0   1000\n"
-  "6 7     30      0  -1000\n"
-  "7 5   -120      0      0\n";
-
-char test_neg2_lgf[] =
-  "@nodes\n"
-  "label   sup\n"
-  "    1   100\n"
-  "    2  -300\n"
-  "@arcs\n"
-  "      cost\n"
-  "1 2     -1\n";
-
-
-// Test data
-typedef ListDigraph Digraph;
-DIGRAPH_TYPEDEFS(ListDigraph);
-
-Digraph gr;
-Digraph::ArcMap<int> c(gr), l1(gr), l2(gr), l3(gr), u(gr);
-Digraph::NodeMap<int> s1(gr), s2(gr), s3(gr), s4(gr), s5(gr), s6(gr);
-ConstMap<Arc, int> cc(1), cu(std::numeric_limits<int>::max());
-Node v, w;
-
-Digraph neg1_gr;
-Digraph::ArcMap<int> neg1_c(neg1_gr), neg1_l1(neg1_gr), neg1_l2(neg1_gr);
-ConstMap<Arc, int> neg1_u1(std::numeric_limits<int>::max()), neg1_u2(5000);
-Digraph::NodeMap<int> neg1_s(neg1_gr);
-
-Digraph neg2_gr;
-Digraph::ArcMap<int> neg2_c(neg2_gr);
-ConstMap<Arc, int> neg2_l(0), neg2_u(1000);
-Digraph::NodeMap<int> neg2_s(neg2_gr);
-
 
 enum SupplyType {
@@ -141,5 +84,4 @@
 };
 
-
 // Check the interface of an MCF algorithm
 template <typename GR, typename Value, typename Cost>
@@ -152,5 +94,5 @@
     void constraints() {
       checkConcept<concepts::Digraph, GR>();
-
+      
       const Constraints& me = *this;
 
@@ -158,5 +100,5 @@
       const MCF& const_mcf = mcf;
 
-      b = mcf.reset().resetParams()
+      b = mcf.reset()
              .lowerMap(me.lower)
              .upperMap(me.upper)
@@ -181,5 +123,5 @@
     typedef concepts::WriteMap<Arc, Value> FlowMap;
     typedef concepts::WriteMap<Node, Cost> PotMap;
-
+  
     GR g;
     VAM lower;
@@ -235,5 +177,5 @@
            typename CM, typename SM, typename FM, typename PM >
 bool checkPotential( const GR& gr, const LM& lower, const UM& upper,
-                     const CM& cost, const SM& supply, const FM& flow,
+                     const CM& cost, const SM& supply, const FM& flow, 
                      const PM& pi, SupplyType type )
 {
@@ -248,5 +190,5 @@
           (red_cost < 0 && flow[e] == upper[e]);
   }
-
+  
   for (NodeIt n(gr); opt && n != INVALID; ++n) {
     typename SM::Value sum = 0;
@@ -261,5 +203,5 @@
     }
   }
-
+  
   return opt;
 }
@@ -286,5 +228,5 @@
     }
   }
-
+  
   for (NodeIt n(gr); n != INVALID; ++n) {
     dual_cost -= red_supply[n] * pi[n];
@@ -295,5 +237,5 @@
     dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
   }
-
+  
   return dual_cost == total;
 }
@@ -327,97 +269,28 @@
 }
 
-template < typename MCF, typename Param >
-void runMcfGeqTests( Param param,
-                     const std::string &test_str = "",
-                     bool full_neg_cost_support = false )
-{
-  MCF mcf1(gr), mcf2(neg1_gr), mcf3(neg2_gr);
-
-  // Basic tests
-  mcf1.upperMap(u).costMap(c).supplyMap(s1);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s1,
-           mcf1.OPTIMAL, true,     5240, test_str + "-1");
-  mcf1.stSupply(v, w, 27);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s2,
-           mcf1.OPTIMAL, true,     7620, test_str + "-2");
-  mcf1.lowerMap(l2).supplyMap(s1);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s1,
-           mcf1.OPTIMAL, true,     5970, test_str + "-3");
-  mcf1.stSupply(v, w, 27);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s2,
-           mcf1.OPTIMAL, true,     8010, test_str + "-4");
-  mcf1.resetParams().supplyMap(s1);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s1,
-           mcf1.OPTIMAL, true,       74, test_str + "-5");
-  mcf1.lowerMap(l2).stSupply(v, w, 27);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, cu, cc, s2,
-           mcf1.OPTIMAL, true,       94, test_str + "-6");
-  mcf1.reset();
-  checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s3,
-           mcf1.OPTIMAL, true,        0, test_str + "-7");
-  mcf1.lowerMap(l2).upperMap(u);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, cc, s3,
-           mcf1.INFEASIBLE, false,    0, test_str + "-8");
-  mcf1.lowerMap(l3).upperMap(u).costMap(c).supplyMap(s4);
-  checkMcf(mcf1, mcf1.run(param), gr, l3, u, c, s4,
-           mcf1.OPTIMAL, true,     6360, test_str + "-9");
-
-  // Tests for the GEQ form
-  mcf1.resetParams().upperMap(u).costMap(c).supplyMap(s5);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s5,
-           mcf1.OPTIMAL, true,     3530, test_str + "-10", GEQ);
-  mcf1.lowerMap(l2);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s5,
-           mcf1.OPTIMAL, true,     4540, test_str + "-11", GEQ);
-  mcf1.supplyMap(s6);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s6,
-           mcf1.INFEASIBLE, false,    0, test_str + "-12", GEQ);
-
-  // Tests with negative costs
-  mcf2.lowerMap(neg1_l1).costMap(neg1_c).supplyMap(neg1_s);
-  checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u1, neg1_c, neg1_s,
-           mcf2.UNBOUNDED, false,     0, test_str + "-13");
-  mcf2.upperMap(neg1_u2);
-  checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u2, neg1_c, neg1_s,
-           mcf2.OPTIMAL, true,   -40000, test_str + "-14");
-  mcf2.resetParams().lowerMap(neg1_l2).costMap(neg1_c).supplyMap(neg1_s);
-  checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l2, neg1_u1, neg1_c, neg1_s,
-           mcf2.UNBOUNDED, false,     0, test_str + "-15");
-
-  mcf3.costMap(neg2_c).supplyMap(neg2_s);
-  if (full_neg_cost_support) {
-    checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
-             mcf3.OPTIMAL, true,   -300, test_str + "-16", GEQ);
-  } else {
-    checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
-             mcf3.UNBOUNDED, false,   0, test_str + "-17", GEQ);
-  }
-  mcf3.upperMap(neg2_u);
-  checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
-           mcf3.OPTIMAL, true,     -300, test_str + "-18", GEQ);
-}
-
-template < typename MCF, typename Param >
-void runMcfLeqTests( Param param,
-                     const std::string &test_str = "" )
-{
-  // Tests for the LEQ form
-  MCF mcf1(gr);
-  mcf1.supplyType(mcf1.LEQ);
-  mcf1.upperMap(u).costMap(c).supplyMap(s6);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s6,
-           mcf1.OPTIMAL, true,   5080, test_str + "-19", LEQ);
-  mcf1.lowerMap(l2);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s6,
-           mcf1.OPTIMAL, true,   5930, test_str + "-20", LEQ);
-  mcf1.supplyMap(s5);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s5,
-           mcf1.INFEASIBLE, false,  0, test_str + "-21", LEQ);
-}
-
-
 int main()
 {
-  // Read the test networks
+  // Check the interfaces
+  {
+    typedef concepts::Digraph GR;
+    checkConcept< McfClassConcept<GR, int, int>,
+                  NetworkSimplex<GR> >();
+    checkConcept< McfClassConcept<GR, double, double>,
+                  NetworkSimplex<GR, double> >();
+    checkConcept< McfClassConcept<GR, int, double>,
+                  NetworkSimplex<GR, int, double> >();
+  }
+
+  // Run various MCF tests
+  typedef ListDigraph Digraph;
+  DIGRAPH_TYPEDEFS(ListDigraph);
+
+  // Read the test digraph
+  Digraph gr;
+  Digraph::ArcMap<int> c(gr), l1(gr), l2(gr), l3(gr), u(gr);
+  Digraph::NodeMap<int> s1(gr), s2(gr), s3(gr), s4(gr), s5(gr), s6(gr);
+  ConstMap<Arc, int> cc(1), cu(std::numeric_limits<int>::max());
+  Node v, w;
+
   std::istringstream input(test_lgf);
   DigraphReader<Digraph>(gr, input)
@@ -436,105 +309,140 @@
     .node("target", w)
     .run();
-
-  std::istringstream neg_inp1(test_neg1_lgf);
-  DigraphReader<Digraph>(neg1_gr, neg_inp1)
-    .arcMap("cost", neg1_c)
-    .arcMap("low1", neg1_l1)
-    .arcMap("low2", neg1_l2)
-    .nodeMap("sup", neg1_s)
-    .run();
-
-  std::istringstream neg_inp2(test_neg2_lgf);
-  DigraphReader<Digraph>(neg2_gr, neg_inp2)
-    .arcMap("cost", neg2_c)
-    .nodeMap("sup", neg2_s)
-    .run();
-
-  // Check the interface of NetworkSimplex
+  
+  // Build test digraphs with negative costs
+  Digraph neg_gr;
+  Node n1 = neg_gr.addNode();
+  Node n2 = neg_gr.addNode();
+  Node n3 = neg_gr.addNode();
+  Node n4 = neg_gr.addNode();
+  Node n5 = neg_gr.addNode();
+  Node n6 = neg_gr.addNode();
+  Node n7 = neg_gr.addNode();
+  
+  Arc a1 = neg_gr.addArc(n1, n2);
+  Arc a2 = neg_gr.addArc(n1, n3);
+  Arc a3 = neg_gr.addArc(n2, n4);
+  Arc a4 = neg_gr.addArc(n3, n4);
+  Arc a5 = neg_gr.addArc(n3, n2);
+  Arc a6 = neg_gr.addArc(n5, n3);
+  Arc a7 = neg_gr.addArc(n5, n6);
+  Arc a8 = neg_gr.addArc(n6, n7);
+  Arc a9 = neg_gr.addArc(n7, n5);
+  
+  Digraph::ArcMap<int> neg_c(neg_gr), neg_l1(neg_gr, 0), neg_l2(neg_gr, 0);
+  ConstMap<Arc, int> neg_u1(std::numeric_limits<int>::max()), neg_u2(5000);
+  Digraph::NodeMap<int> neg_s(neg_gr, 0);
+  
+  neg_l2[a7] =  1000;
+  neg_l2[a8] = -1000;
+  
+  neg_s[n1] =  100;
+  neg_s[n4] = -100;
+  
+  neg_c[a1] =  100;
+  neg_c[a2] =   30;
+  neg_c[a3] =   20;
+  neg_c[a4] =   80;
+  neg_c[a5] =   50;
+  neg_c[a6] =   10;
+  neg_c[a7] =   80;
+  neg_c[a8] =   30;
+  neg_c[a9] = -120;
+
+  Digraph negs_gr;
+  Digraph::NodeMap<int> negs_s(negs_gr);
+  Digraph::ArcMap<int> negs_c(negs_gr);
+  ConstMap<Arc, int> negs_l(0), negs_u(1000);
+  n1 = negs_gr.addNode();
+  n2 = negs_gr.addNode();
+  negs_s[n1] = 100;
+  negs_s[n2] = -300;
+  negs_c[negs_gr.addArc(n1, n2)] = -1;
+
+
+  // A. Test NetworkSimplex with the default pivot rule
   {
-    typedef concepts::Digraph GR;
-    checkConcept< McfClassConcept<GR, int, int>,
-                  NetworkSimplex<GR> >();
-    checkConcept< McfClassConcept<GR, double, double>,
-                  NetworkSimplex<GR, double> >();
-    checkConcept< McfClassConcept<GR, int, double>,
-                  NetworkSimplex<GR, int, double> >();
-  }
-
-  // Check the interface of CapacityScaling
+    NetworkSimplex<Digraph> mcf(gr);
+
+    // Check the equality form
+    mcf.upperMap(u).costMap(c);
+    checkMcf(mcf, mcf.supplyMap(s1).run(),
+             gr, l1, u, c, s1, mcf.OPTIMAL, true,   5240, "#A1");
+    checkMcf(mcf, mcf.stSupply(v, w, 27).run(),
+             gr, l1, u, c, s2, mcf.OPTIMAL, true,   7620, "#A2");
+    mcf.lowerMap(l2);
+    checkMcf(mcf, mcf.supplyMap(s1).run(),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#A3");
+    checkMcf(mcf, mcf.stSupply(v, w, 27).run(),
+             gr, l2, u, c, s2, mcf.OPTIMAL, true,   8010, "#A4");
+    mcf.reset();
+    checkMcf(mcf, mcf.supplyMap(s1).run(),
+             gr, l1, cu, cc, s1, mcf.OPTIMAL, true,   74, "#A5");
+    checkMcf(mcf, mcf.lowerMap(l2).stSupply(v, w, 27).run(),
+             gr, l2, cu, cc, s2, mcf.OPTIMAL, true,   94, "#A6");
+    mcf.reset();
+    checkMcf(mcf, mcf.run(),
+             gr, l1, cu, cc, s3, mcf.OPTIMAL, true,    0, "#A7");
+    checkMcf(mcf, mcf.lowerMap(l2).upperMap(u).run(),
+             gr, l2, u, cc, s3, mcf.INFEASIBLE, false, 0, "#A8");
+    mcf.reset().lowerMap(l3).upperMap(u).costMap(c).supplyMap(s4);
+    checkMcf(mcf, mcf.run(),
+             gr, l3, u, c, s4, mcf.OPTIMAL, true,   6360, "#A9");
+
+    // Check the GEQ form
+    mcf.reset().upperMap(u).costMap(c).supplyMap(s5);
+    checkMcf(mcf, mcf.run(),
+             gr, l1, u, c, s5, mcf.OPTIMAL, true,   3530, "#A10", GEQ);
+    mcf.supplyType(mcf.GEQ);
+    checkMcf(mcf, mcf.lowerMap(l2).run(),
+             gr, l2, u, c, s5, mcf.OPTIMAL, true,   4540, "#A11", GEQ);
+    mcf.supplyMap(s6);
+    checkMcf(mcf, mcf.run(),
+             gr, l2, u, c, s6, mcf.INFEASIBLE, false,  0, "#A12", GEQ);
+
+    // Check the LEQ form
+    mcf.reset().supplyType(mcf.LEQ);
+    mcf.upperMap(u).costMap(c).supplyMap(s6);
+    checkMcf(mcf, mcf.run(),
+             gr, l1, u, c, s6, mcf.OPTIMAL, true,   5080, "#A13", LEQ);
+    checkMcf(mcf, mcf.lowerMap(l2).run(),
+             gr, l2, u, c, s6, mcf.OPTIMAL, true,   5930, "#A14", LEQ);
+    mcf.supplyMap(s5);
+    checkMcf(mcf, mcf.run(),
+             gr, l2, u, c, s5, mcf.INFEASIBLE, false,  0, "#A15", LEQ);
+
+    // Check negative costs
+    NetworkSimplex<Digraph> neg_mcf(neg_gr);
+    neg_mcf.lowerMap(neg_l1).costMap(neg_c).supplyMap(neg_s);
+    checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l1, neg_u1,
+      neg_c, neg_s, neg_mcf.UNBOUNDED, false,    0, "#A16");
+    neg_mcf.upperMap(neg_u2);
+    checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l1, neg_u2,
+      neg_c, neg_s, neg_mcf.OPTIMAL, true,  -40000, "#A17");
+    neg_mcf.reset().lowerMap(neg_l2).costMap(neg_c).supplyMap(neg_s);
+    checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l2, neg_u1,
+      neg_c, neg_s, neg_mcf.UNBOUNDED, false,    0, "#A18");
+      
+    NetworkSimplex<Digraph> negs_mcf(negs_gr);
+    negs_mcf.costMap(negs_c).supplyMap(negs_s);
+    checkMcf(negs_mcf, negs_mcf.run(), negs_gr, negs_l, negs_u,
+      negs_c, negs_s, negs_mcf.OPTIMAL, true, -300, "#A19", GEQ);
+  }
+
+  // B. Test NetworkSimplex with each pivot rule
   {
-    typedef concepts::Digraph GR;
-    checkConcept< McfClassConcept<GR, int, int>,
-                  CapacityScaling<GR> >();
-    checkConcept< McfClassConcept<GR, double, double>,
-                  CapacityScaling<GR, double> >();
-    checkConcept< McfClassConcept<GR, int, double>,
-                  CapacityScaling<GR, int, double> >();
-    typedef CapacityScaling<GR>::
-      SetHeap<concepts::Heap<int, RangeMap<int> > >::Create CAS;
-    checkConcept< McfClassConcept<GR, int, int>, CAS >();
-  }
-
-  // Check the interface of CostScaling
-  {
-    typedef concepts::Digraph GR;
-    checkConcept< McfClassConcept<GR, int, int>,
-                  CostScaling<GR> >();
-    checkConcept< McfClassConcept<GR, double, double>,
-                  CostScaling<GR, double> >();
-    checkConcept< McfClassConcept<GR, int, double>,
-                  CostScaling<GR, int, double> >();
-    typedef CostScaling<GR>::
-      SetLargeCost<double>::Create COS;
-    checkConcept< McfClassConcept<GR, int, int>, COS >();
-  }
-
-  // Check the interface of CycleCanceling
-  {
-    typedef concepts::Digraph GR;
-    checkConcept< McfClassConcept<GR, int, int>,
-                  CycleCanceling<GR> >();
-    checkConcept< McfClassConcept<GR, double, double>,
-                  CycleCanceling<GR, double> >();
-    checkConcept< McfClassConcept<GR, int, double>,
-                  CycleCanceling<GR, int, double> >();
-  }
-
-  // Test NetworkSimplex
-  {
-    typedef NetworkSimplex<Digraph> MCF;
-    runMcfGeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE", true);
-    runMcfLeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE");
-    runMcfGeqTests<MCF>(MCF::BEST_ELIGIBLE,  "NS-BE", true);
-    runMcfLeqTests<MCF>(MCF::BEST_ELIGIBLE,  "NS-BE");
-    runMcfGeqTests<MCF>(MCF::BLOCK_SEARCH,   "NS-BS", true);
-    runMcfLeqTests<MCF>(MCF::BLOCK_SEARCH,   "NS-BS");
-    runMcfGeqTests<MCF>(MCF::CANDIDATE_LIST, "NS-CL", true);
-    runMcfLeqTests<MCF>(MCF::CANDIDATE_LIST, "NS-CL");
-    runMcfGeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL", true);
-    runMcfLeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL");
-  }
-
-  // Test CapacityScaling
-  {
-    typedef CapacityScaling<Digraph> MCF;
-    runMcfGeqTests<MCF>(0, "SSP");
-    runMcfGeqTests<MCF>(2, "CAS");
-  }
-
-  // Test CostScaling
-  {
-    typedef CostScaling<Digraph> MCF;
-    runMcfGeqTests<MCF>(MCF::PUSH, "COS-PR");
-    runMcfGeqTests<MCF>(MCF::AUGMENT, "COS-AR");
-    runMcfGeqTests<MCF>(MCF::PARTIAL_AUGMENT, "COS-PAR");
-  }
-
-  // Test CycleCanceling
-  {
-    typedef CycleCanceling<Digraph> MCF;
-    runMcfGeqTests<MCF>(MCF::SIMPLE_CYCLE_CANCELING, "SCC");
-    runMcfGeqTests<MCF>(MCF::MINIMUM_MEAN_CYCLE_CANCELING, "MMCC");
-    runMcfGeqTests<MCF>(MCF::CANCEL_AND_TIGHTEN, "CAT");
+    NetworkSimplex<Digraph> mcf(gr);
+    mcf.supplyMap(s1).costMap(c).upperMap(u).lowerMap(l2);
+
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::FIRST_ELIGIBLE),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B1");
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::BEST_ELIGIBLE),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B2");
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::BLOCK_SEARCH),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B3");
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::CANDIDATE_LIST),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B4");
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::ALTERING_LIST),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B5");
   }
 
Index: test/min_mean_cycle_test.cc
===================================================================
--- test/min_mean_cycle_test.cc	(revision 877)
+++ 	(revision )
@@ -1,216 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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 <lemon/smart_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/path.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concept_check.h>
-
-#include <lemon/karp_mmc.h>
-#include <lemon/hartmann_orlin_mmc.h>
-#include <lemon/howard_mmc.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@arcs\n"
-  "    len1 len2 len3 len4  c1 c2 c3 c4\n"
-  "1 2    1    1    1    1   0  0  0  0\n"
-  "2 4    5    5    5    5   1  0  0  0\n"
-  "2 3    8    8    8    8   0  0  0  0\n"
-  "3 2   -2    0    0    0   1  0  0  0\n"
-  "3 4    4    4    4    4   0  0  0  0\n"
-  "3 7   -4   -4   -4   -4   0  0  0  0\n"
-  "4 1    2    2    2    2   0  0  0  0\n"
-  "4 3    3    3    3    3   1  0  0  0\n"
-  "4 4    3    3    0    0   0  0  1  0\n"
-  "5 2    4    4    4    4   0  0  0  0\n"
-  "5 6    3    3    3    3   0  1  0  0\n"
-  "6 5    2    2    2    2   0  1  0  0\n"
-  "6 4   -1   -1   -1   -1   0  0  0  0\n"
-  "6 7    1    1    1    1   0  0  0  0\n"
-  "7 7    4    4    4   -1   0  0  0  1\n";
-
-
-// Check the interface of an MMC algorithm
-template <typename GR, typename Cost>
-struct MmcClassConcept
-{
-  template <typename MMC>
-  struct Constraints {
-    void constraints() {
-      const Constraints& me = *this;
-
-      typedef typename MMC
-        ::template SetPath<ListPath<GR> >
-        ::template SetLargeCost<Cost>
-        ::Create MmcAlg;
-      MmcAlg mmc(me.g, me.cost);
-      const MmcAlg& const_mmc = mmc;
-
-      typename MmcAlg::Tolerance tol = const_mmc.tolerance();
-      mmc.tolerance(tol);
-
-      b = mmc.cycle(p).run();
-      b = mmc.findCycleMean();
-      b = mmc.findCycle();
-
-      v = const_mmc.cycleCost();
-      i = const_mmc.cycleSize();
-      d = const_mmc.cycleMean();
-      p = const_mmc.cycle();
-    }
-
-    typedef concepts::ReadMap<typename GR::Arc, Cost> CM;
-
-    GR g;
-    CM cost;
-    ListPath<GR> p;
-    Cost v;
-    int i;
-    double d;
-    bool b;
-  };
-};
-
-// Perform a test with the given parameters
-template <typename MMC>
-void checkMmcAlg(const SmartDigraph& gr,
-                 const SmartDigraph::ArcMap<int>& lm,
-                 const SmartDigraph::ArcMap<int>& cm,
-                 int cost, int size) {
-  MMC alg(gr, lm);
-  alg.findCycleMean();
-  check(alg.cycleMean() == static_cast<double>(cost) / size,
-        "Wrong cycle mean");
-  alg.findCycle();
-  check(alg.cycleCost() == cost && alg.cycleSize() == size,
-        "Wrong path");
-  SmartDigraph::ArcMap<int> cycle(gr, 0);
-  for (typename MMC::Path::ArcIt a(alg.cycle()); a != INVALID; ++a) {
-    ++cycle[a];
-  }
-  for (SmartDigraph::ArcIt a(gr); a != INVALID; ++a) {
-    check(cm[a] == cycle[a], "Wrong path");
-  }
-}
-
-// Class for comparing types
-template <typename T1, typename T2>
-struct IsSameType {
-  static const int result = 0;
-};
-
-template <typename T>
-struct IsSameType<T,T> {
-  static const int result = 1;
-};
-
-
-int main() {
-  #ifdef LEMON_HAVE_LONG_LONG
-    typedef long long long_int;
-  #else
-    typedef long long_int;
-  #endif
-
-  // Check the interface
-  {
-    typedef concepts::Digraph GR;
-
-    // KarpMmc
-    checkConcept< MmcClassConcept<GR, int>,
-                  KarpMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
-    checkConcept< MmcClassConcept<GR, float>,
-                  KarpMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    // HartmannOrlinMmc
-    checkConcept< MmcClassConcept<GR, int>,
-                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
-    checkConcept< MmcClassConcept<GR, float>,
-                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    // HowardMmc
-    checkConcept< MmcClassConcept<GR, int>,
-                  HowardMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
-    checkConcept< MmcClassConcept<GR, float>,
-                  HowardMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, int> >
-           ::LargeCost, long_int>::result == 1), "Wrong LargeCost type");
-    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, float> >
-           ::LargeCost, double>::result == 1), "Wrong LargeCost type");
-  }
-
-  // Run various tests
-  {
-    typedef SmartDigraph GR;
-    DIGRAPH_TYPEDEFS(GR);
-
-    GR gr;
-    IntArcMap l1(gr), l2(gr), l3(gr), l4(gr);
-    IntArcMap c1(gr), c2(gr), c3(gr), c4(gr);
-
-    std::istringstream input(test_lgf);
-    digraphReader(gr, input).
-      arcMap("len1", l1).
-      arcMap("len2", l2).
-      arcMap("len3", l3).
-      arcMap("len4", l4).
-      arcMap("c1", c1).
-      arcMap("c2", c2).
-      arcMap("c3", c3).
-      arcMap("c4", c4).
-      run();
-
-    // Karp
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-
-    // HartmannOrlin
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-
-    // Howard
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-  }
-
-  return 0;
-}
Index: test/planarity_test.cc
===================================================================
--- test/planarity_test.cc	(revision 798)
+++ 	(revision )
@@ -1,262 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * 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 <lemon/planarity.h>
-
-#include <lemon/smart_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/connectivity.h>
-#include <lemon/dim2.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-using namespace lemon::dim2;
-
-const int lgfn = 4;
-const std::string lgf[lgfn] = {
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "@edges\n"
-  "     label\n"
-  "0 1  0\n"
-  "0 2  0\n"
-  "0 3  0\n"
-  "0 4  0\n"
-  "1 2  0\n"
-  "1 3  0\n"
-  "1 4  0\n"
-  "2 3  0\n"
-  "2 4  0\n"
-  "3 4  0\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "@edges\n"
-  "     label\n"
-  "0 1  0\n"
-  "0 2  0\n"
-  "0 3  0\n"
-  "0 4  0\n"
-  "1 2  0\n"
-  "1 3  0\n"
-  "2 3  0\n"
-  "2 4  0\n"
-  "3 4  0\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "@edges\n"
-  "     label\n"
-  "0 3  0\n"
-  "0 4  0\n"
-  "0 5  0\n"
-  "1 3  0\n"
-  "1 4  0\n"
-  "1 5  0\n"
-  "2 3  0\n"
-  "2 4  0\n"
-  "2 5  0\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "@edges\n"
-  "     label\n"
-  "0 3  0\n"
-  "0 4  0\n"
-  "0 5  0\n"
-  "1 3  0\n"
-  "1 4  0\n"
-  "1 5  0\n"
-  "2 3  0\n"
-  "2 5  0\n"
-};
-
-
-
-typedef SmartGraph Graph;
-GRAPH_TYPEDEFS(Graph);
-
-typedef PlanarEmbedding<SmartGraph> PE;
-typedef PlanarDrawing<SmartGraph> PD;
-typedef PlanarColoring<SmartGraph> PC;
-
-void checkEmbedding(const Graph& graph, PE& pe) {
-  int face_num = 0;
-
-  Graph::ArcMap<int> face(graph, -1);
-
-  for (ArcIt a(graph); a != INVALID; ++a) {
-    if (face[a] == -1) {
-      Arc b = a;
-      while (face[b] == -1) {
-        face[b] = face_num;
-        b = pe.next(graph.oppositeArc(b));
-      }
-      check(face[b] == face_num, "Wrong face");
-      ++face_num;
-    }
-  }
-  check(face_num + countNodes(graph) - countConnectedComponents(graph) ==
-        countEdges(graph) + 1, "Euler test does not passed");
-}
-
-void checkKuratowski(const Graph& graph, PE& pe) {
-  std::map<int, int> degs;
-  for (NodeIt n(graph); n != INVALID; ++n) {
-    int deg = 0;
-    for (IncEdgeIt e(graph, n); e != INVALID; ++e) {
-      if (pe.kuratowski(e)) {
-        ++deg;
-      }
-    }
-    ++degs[deg];
-  }
-  for (std::map<int, int>::iterator it = degs.begin(); it != degs.end(); ++it) {
-    check(it->first == 0 || it->first == 2 ||
-          (it->first == 3 && it->second == 6) ||
-          (it->first == 4 && it->second == 5),
-          "Wrong degree in Kuratowski graph");
-  }
-
-  // Not full test
-  check((degs[3] == 0) != (degs[4] == 0), "Wrong Kuratowski graph");
-}
-
-bool intersect(Point<int> e1, Point<int> e2, Point<int> f1, Point<int> f2) {
-  int l, r;
-  if (std::min(e1.x, e2.x) > std::max(f1.x, f2.x)) return false;
-  if (std::max(e1.x, e2.x) < std::min(f1.x, f2.x)) return false;
-  if (std::min(e1.y, e2.y) > std::max(f1.y, f2.y)) return false;
-  if (std::max(e1.y, e2.y) < std::min(f1.y, f2.y)) return false;
-
-  l = (e2.x - e1.x) * (f1.y - e1.y) - (e2.y - e1.y) * (f1.x - e1.x);
-  r = (e2.x - e1.x) * (f2.y - e1.y) - (e2.y - e1.y) * (f2.x - e1.x);
-  if (!((l >= 0 && r <= 0) || (l <= 0 && r >= 0))) return false;
-  l = (f2.x - f1.x) * (e1.y - f1.y) - (f2.y - f1.y) * (e1.x - f1.x);
-  r = (f2.x - f1.x) * (e2.y - f1.y) - (f2.y - f1.y) * (e2.x - f1.x);
-  if (!((l >= 0 && r <= 0) || (l <= 0 && r >= 0))) return false;
-  return true;
-}
-
-bool collinear(Point<int> p, Point<int> q, Point<int> r) {
-  int v;
-  v = (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x);
-  if (v != 0) return false;
-  v = (q.x - p.x) * (r.x - p.x) + (q.y - p.y) * (r.y - p.y);
-  if (v < 0) return false;
-  return true;
-}
-
-void checkDrawing(const Graph& graph, PD& pd) {
-  for (Graph::NodeIt n(graph); n != INVALID; ++n) {
-    Graph::NodeIt m(n);
-    for (++m; m != INVALID; ++m) {
-      check(pd[m] != pd[n], "Two nodes with identical coordinates");
-    }
-  }
-
-  for (Graph::EdgeIt e(graph); e != INVALID; ++e) {
-    for (Graph::EdgeIt f(e); f != e; ++f) {
-      Point<int> e1 = pd[graph.u(e)];
-      Point<int> e2 = pd[graph.v(e)];
-      Point<int> f1 = pd[graph.u(f)];
-      Point<int> f2 = pd[graph.v(f)];
-
-      if (graph.u(e) == graph.u(f)) {
-        check(!collinear(e1, e2, f2), "Wrong drawing");
-      } else if (graph.u(e) == graph.v(f)) {
-        check(!collinear(e1, e2, f1), "Wrong drawing");
-      } else if (graph.v(e) == graph.u(f)) {
-        check(!collinear(e2, e1, f2), "Wrong drawing");
-      } else if (graph.v(e) == graph.v(f)) {
-        check(!collinear(e2, e1, f1), "Wrong drawing");
-      } else {
-        check(!intersect(e1, e2, f1, f2), "Wrong drawing");
-      }
-    }
-  }
-}
-
-void checkColoring(const Graph& graph, PC& pc, int num) {
-  for (NodeIt n(graph); n != INVALID; ++n) {
-    check(pc.colorIndex(n) >= 0 && pc.colorIndex(n) < num,
-          "Wrong coloring");
-  }
-  for (EdgeIt e(graph); e != INVALID; ++e) {
-    check(pc.colorIndex(graph.u(e)) != pc.colorIndex(graph.v(e)),
-          "Wrong coloring");
-  }
-}
-
-int main() {
-
-  for (int i = 0; i < lgfn; ++i) {
-    std::istringstream lgfs(lgf[i]);
-
-    SmartGraph graph;
-    graphReader(graph, lgfs).run();
-
-    check(simpleGraph(graph), "Test graphs must be simple");
-
-    PE pe(graph);
-    bool planar = pe.run();
-    check(checkPlanarity(graph) == planar, "Planarity checking failed");
-
-    if (planar) {
-      checkEmbedding(graph, pe);
-
-      PlanarDrawing<Graph> pd(graph);
-      pd.run(pe.embeddingMap());
-      checkDrawing(graph, pd);
-
-      PlanarColoring<Graph> pc(graph);
-      pc.runFiveColoring(pe.embeddingMap());
-      checkColoring(graph, pc, 5);
-
-    } else {
-      checkKuratowski(graph, pe);
-    }
-  }
-
-  return 0;
-}
Index: test/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 927)
+++ test/preflow_test.cc	(revision 901)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -96,9 +96,4 @@
   const PreflowType& const_preflow_test = preflow_test;
 
-  const PreflowType::Elevator& elev = const_preflow_test.elevator();
-  preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
-  PreflowType::Tolerance tol = const_preflow_test.tolerance();
-  preflow_test.tolerance(tol);
-
   preflow_test
     .capacityMap(cap)
@@ -119,5 +114,5 @@
   b = const_preflow_test.minCut(n);
   const_preflow_test.minCutMap(cut);
-
+  
   ignore_unused_variable_warning(fm);
 }
@@ -160,5 +155,5 @@
 {
   DIGRAPH_TYPEDEFS(SmartDigraph);
-
+  
   SmartDigraph g;
   SmartDigraph::ArcMap<int> cap(g),iflow(g);
@@ -272,5 +267,5 @@
 
   initFlowTest();
-
+  
   return 0;
 }
Index: test/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 877)
+++ test/suurballe_test.cc	(revision 623)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,4 @@
 #include <lemon/suurballe.h>
 #include <lemon/concepts/digraph.h>
-#include <lemon/concepts/heap.h>
 
 #include "test_tools.h"
@@ -82,12 +81,6 @@
   typedef Digraph::Arc Arc;
   typedef concepts::ReadMap<Arc, VType> LengthMap;
-
-  typedef Suurballe<Digraph, LengthMap> ST;
-  typedef Suurballe<Digraph, LengthMap>
-    ::SetFlowMap<ST::FlowMap>
-    ::SetPotentialMap<ST::PotentialMap>
-    ::SetPath<SimplePath<Digraph> >
-    ::SetHeap<concepts::Heap<VType, Digraph::NodeMap<int> > >
-    ::Create SuurballeType;
+  
+  typedef Suurballe<Digraph, LengthMap> SuurballeType;
 
   Digraph g;
@@ -109,11 +102,8 @@
   k = suurb_test.run(n, n, k);
   suurb_test.init(n);
-  suurb_test.fullInit(n);
-  suurb_test.start(n);
-  suurb_test.start(n, k);
   k = suurb_test.findFlow(n);
   k = suurb_test.findFlow(n, k);
   suurb_test.findPaths();
-
+  
   int f;
   VType c;
@@ -127,5 +117,5 @@
   k = const_suurb_test.pathNum();
   Path<Digraph> p = const_suurb_test.path(k);
-
+  
   ignore_unused_variable_warning(fm);
   ignore_unused_variable_warning(pm);
@@ -206,9 +196,7 @@
     run();
 
-  // Check run()
+  // Find 2 paths
   {
     Suurballe<ListDigraph> suurballe(digraph, length);
-
-    // Find 2 paths
     check(suurballe.run(s, t) == 2, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 2),
@@ -220,6 +208,9 @@
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-
-    // Find 3 paths
+  }
+
+  // Find 3 paths
+  {
+    Suurballe<ListDigraph> suurballe(digraph, length);
     check(suurballe.run(s, t, 3) == 3, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
@@ -231,6 +222,9 @@
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-
-    // Find 5 paths (only 3 can be found)
+  }
+
+  // Find 5 paths (only 3 can be found)
+  {
+    Suurballe<ListDigraph> suurballe(digraph, length);
     check(suurballe.run(s, t, 5) == 3, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
@@ -244,22 +238,4 @@
   }
 
-  // Check fullInit() + start()
-  {
-    Suurballe<ListDigraph> suurballe(digraph, length);
-    suurballe.fullInit(s);
-
-    // Find 2 paths
-    check(suurballe.start(t) == 2, "Wrong number of paths");
-    check(suurballe.totalLength() == 510, "The flow is not optimal");
-
-    // Find 3 paths
-    check(suurballe.start(t, 3) == 3, "Wrong number of paths");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-
-    // Find 5 paths (only 3 can be found)
-    check(suurballe.start(t, 5) == 3, "Wrong number of paths");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-  }
-
   return 0;
 }
Index: test/test_tools.h
===================================================================
--- test/test_tools.h	(revision 877)
+++ test/test_tools.h	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -38,13 +38,9 @@
 ///print something like this (and then exits).
 ///\verbatim file_name.cc:123: error: This is obviously false. \endverbatim
-#define check(rc, msg)                                                  \
-  {                                                                     \
-    if(!(rc)) {                                                         \
-      std::cerr << __FILE__ ":" << __LINE__ << ": error: "              \
-                << msg << std::endl;                                    \
-      abort();                                                          \
-    } else { }                                                          \
-  }                                                                     \
-
+#define check(rc, msg) \
+  if(!(rc)) { \
+    std::cerr << __FILE__ ":" << __LINE__ << ": error: " << msg << std::endl; \
+    abort(); \
+  } else { } \
 
 #endif
