Index: test/CMakeLists.txt
===================================================================
--- test/CMakeLists.txt	(revision 1264)
+++ test/CMakeLists.txt	(revision 1161)
@@ -17,5 +17,4 @@
   bellman_ford_test
   bfs_test
-  bpgraph_test
   circulation_test
   connectivity_test
@@ -36,22 +35,17 @@
   heap_test
   kruskal_test
-  lgf_reader_writer_test
   lgf_test
   maps_test
   matching_test
-  max_cardinality_search_test
-  max_clique_test
-  max_flow_test
   min_cost_arborescence_test
   min_cost_flow_test
   min_mean_cycle_test
-  nagamochi_ibaraki_test
   path_test
   planarity_test
+  preflow_test
   radix_sort_test
   random_test
   suurballe_test
   time_measure_test
-  tsp_test
   unionfind_test
 )
@@ -70,11 +64,8 @@
   ENDIF()
   IF(LEMON_HAVE_CPLEX)
-    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${ILOG_LIBRARIES})
+    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${CPLEX_LIBRARIES})
   ENDIF()
   IF(LEMON_HAVE_CLP)
     SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${COIN_CLP_LIBRARIES})
-  ENDIF()
-  IF(LEMON_HAVE_SOPLEX)
-    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${SOPLEX_LIBRARIES})
   ENDIF()
 
@@ -97,5 +88,5 @@
     GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
     ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${ILOG_CPLEX_DLL} ${TARGET_PATH}
+      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex.dll ${TARGET_PATH}
     )
   ENDIF()
@@ -115,5 +106,5 @@
   ENDIF()
   IF(LEMON_HAVE_CPLEX)
-    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${ILOG_LIBRARIES})
+    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${CPLEX_LIBRARIES})
   ENDIF()
   IF(LEMON_HAVE_CBC)
@@ -139,5 +130,5 @@
     GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
     ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${ILOG_CPLEX_DLL} ${TARGET_PATH}
+      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex.dll ${TARGET_PATH}
     )
   ENDIF()
Index: test/Makefile.am
===================================================================
--- test/Makefile.am	(revision 1324)
+++ test/Makefile.am	(revision 1324)
@@ -0,0 +1,103 @@
+if USE_VALGRIND
+TESTS_ENVIRONMENT=$(top_srcdir)/scripts/valgrind-wrapper.sh
+endif
+
+EXTRA_DIST += \
+	test/CMakeLists.txt
+
+noinst_HEADERS += \
+	test/graph_test.h \
+	test/test_tools.h
+
+check_PROGRAMS += \
+	test/adaptors_test \
+	test/arc_lookup_test \
+	test/bellman_ford_test \
+	test/bfs_test \
+	test/circulation_test \
+	test/connectivity_test \
+	test/counter_test \
+	test/dfs_test \
+	test/digraph_test \
+	test/dijkstra_test \
+	test/dim_test \
+	test/edge_set_test \
+	test/error_test \
+	test/euler_test \
+	test/fractional_matching_test \
+	test/gomory_hu_test \
+	test/graph_copy_test \
+	test/graph_test \
+	test/graph_utils_test \
+	test/hao_orlin_test \
+	test/heap_test \
+	test/kruskal_test \
+	test/lgf_test \
+	test/maps_test \
+	test/matching_test \
+	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 \
+	test/random_test \
+	test/suurballe_test \
+	test/test_tools_fail \
+	test/test_tools_pass \
+	test/time_measure_test \
+	test/unionfind_test
+
+test_test_tools_pass_DEPENDENCIES = demo
+
+if HAVE_LP
+check_PROGRAMS += test/lp_test
+endif HAVE_LP
+if HAVE_MIP
+check_PROGRAMS += test/mip_test
+endif HAVE_MIP
+
+TESTS += $(check_PROGRAMS)
+XFAIL_TESTS += test/test_tools_fail$(EXEEXT)
+
+test_adaptors_test_SOURCES = test/adaptors_test.cc
+test_adaptors_test_SOURCES = test/arc_lookup_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
+test_counter_test_SOURCES = test/counter_test.cc
+test_connectivity_test_SOURCES = test/connectivity_test.cc
+test_dfs_test_SOURCES = test/dfs_test.cc
+test_digraph_test_SOURCES = test/digraph_test.cc
+test_dijkstra_test_SOURCES = test/dijkstra_test.cc
+test_dim_test_SOURCES = test/dim_test.cc
+test_edge_set_test_SOURCES = test/edge_set_test.cc
+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_lgf_test_SOURCES = test/lgf_test.cc
+test_lp_test_SOURCES = test/lp_test.cc
+test_maps_test_SOURCES = test/maps_test.cc
+test_mip_test_SOURCES = test/mip_test.cc
+test_matching_test_SOURCES = test/matching_test.cc
+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
+test_suurballe_test_SOURCES = test/suurballe_test.cc
+test_random_test_SOURCES = test/random_test.cc
+test_test_tools_fail_SOURCES = test/test_tools_fail.cc
+test_test_tools_pass_SOURCES = test/test_tools_pass.cc
+test_time_measure_test_SOURCES = test/time_measure_test.cc
+test_unionfind_test_SOURCES = test/unionfind_test.cc
Index: test/adaptors_test.cc
===================================================================
--- test/adaptors_test.cc	(revision 1270)
+++ test/adaptors_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/arc_look_up_test.cc
===================================================================
--- test/arc_look_up_test.cc	(revision 1312)
+++ test/arc_look_up_test.cc	(revision 1149)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -25,4 +25,5 @@
 using namespace lemon;
 
+const int lgfn = 4;
 const std::string lgf =
   "@nodes\n"
@@ -68,15 +69,15 @@
   std::istringstream lgfs(lgf);
   DigraphReader<ListDigraph>(graph, lgfs).run();
-
+  
   AllArcLookUp<ListDigraph> lookup(graph);
-
+	
   int numArcs = countArcs(graph);
-
+	
   int arcCnt = 0;
   for(ListDigraph::NodeIt n1(graph); n1 != INVALID; ++n1)
     for(ListDigraph::NodeIt n2(graph); n2 != INVALID; ++n2)
       for(ListDigraph::Arc a = lookup(n1, n2); a != INVALID;
-          a = lookup(n1, n2, a))
-        ++arcCnt;
+	  a = lookup(n1, n2, a))
+	++arcCnt;
   check(arcCnt==numArcs, "Wrong total number of arcs");
 
Index: test/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 1270)
+++ test/bellman_ford_test.cc	(revision 1260)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 1270)
+++ test/bfs_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/bpgraph_test.cc
===================================================================
--- test/bpgraph_test.cc	(revision 1292)
+++ 	(revision )
@@ -1,456 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * 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/bpgraph.h>
-#include <lemon/list_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/full_graph.h>
-
-#include "test_tools.h"
-#include "graph_test.h"
-
-using namespace lemon;
-using namespace lemon::concepts;
-
-template <class BpGraph>
-void checkBpGraphBuild() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G;
-  checkGraphNodeList(G, 0);
-  checkGraphRedNodeList(G, 0);
-  checkGraphBlueNodeList(G, 0);
-  checkGraphEdgeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  G.reserveNode(3);
-  G.reserveEdge(3);
-
-  RedNode
-    rn1 = G.addRedNode();
-  checkGraphNodeList(G, 1);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 0);
-  checkGraphEdgeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  BlueNode
-    bn1 = G.addBlueNode(),
-    bn2 = G.addBlueNode();
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  Edge e1 = G.addEdge(rn1, bn2);
-  check(G.redNode(e1) == rn1 && G.blueNode(e1) == bn2, "Wrong edge");
-  check(G.u(e1) == rn1 && G.v(e1) == bn2, "Wrong edge");
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 1);
-  checkGraphArcList(G, 2);
-
-  checkGraphIncEdgeArcLists(G, rn1, 1);
-  checkGraphIncEdgeArcLists(G, bn1, 0);
-  checkGraphIncEdgeArcLists(G, bn2, 1);
-
-  checkGraphConEdgeList(G, 1);
-  checkGraphConArcList(G, 2);
-
-  Edge
-    e2 = G.addEdge(bn1, rn1),
-    e3 = G.addEdge(rn1, bn2);
-  ::lemon::ignore_unused_variable_warning(e2,e3);
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
-
-  checkGraphIncEdgeArcLists(G, rn1, 3);
-  checkGraphIncEdgeArcLists(G, bn1, 1);
-  checkGraphIncEdgeArcLists(G, bn2, 2);
-
-  checkGraphConEdgeList(G, 3);
-  checkGraphConArcList(G, 6);
-
-  checkArcDirections(G);
-
-  checkNodeIds(G);
-  checkRedNodeIds(G);
-  checkBlueNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-
-  checkGraphNodeMap(G);
-  checkGraphRedNodeMap(G);
-  checkGraphBlueNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-}
-
-template <class BpGraph>
-void checkBpGraphErase() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G;
-  RedNode
-    n1 = G.addRedNode(), n4 = G.addRedNode();
-  BlueNode
-    n2 = G.addBlueNode(), n3 = G.addBlueNode();
-  Edge
-    e1 = G.addEdge(n1, n2), e2 = G.addEdge(n1, n3),
-    e3 = G.addEdge(n4, n2), e4 = G.addEdge(n4, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e3,e4);
-
-  // Check edge deletion
-  G.erase(e2);
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-  checkGraphIncEdgeArcLists(G, n3, 1);
-  checkGraphIncEdgeArcLists(G, n4, 2);
-
-  checkGraphConEdgeList(G, 3);
-  checkGraphConArcList(G, 6);
-
-  // Check node deletion
-  G.erase(n3);
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 1);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-  checkGraphIncEdgeArcLists(G, n4, 1);
-
-  checkGraphConEdgeList(G, 2);
-  checkGraphConArcList(G, 4);
-
-}
-
-template <class BpGraph>
-void checkBpGraphAlter() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G;
-  RedNode
-    n1 = G.addRedNode(), n4 = G.addRedNode();
-  BlueNode
-    n2 = G.addBlueNode(), n3 = G.addBlueNode();
-  Edge
-    e1 = G.addEdge(n1, n2), e2 = G.addEdge(n1, n3),
-    e3 = G.addEdge(n4, n2), e4 = G.addEdge(n4, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e3,e4);
-
-  G.changeRed(e2, n4);
-  check(G.redNode(e2) == n4, "Wrong red node");
-  check(G.blueNode(e2) == n3, "Wrong blue node");
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 4);
-  checkGraphArcList(G, 8);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-  checkGraphIncEdgeArcLists(G, n3, 2);
-  checkGraphIncEdgeArcLists(G, n4, 3);
-
-  checkGraphConEdgeList(G, 4);
-  checkGraphConArcList(G, 8);
-
-  G.changeBlue(e2, n2);
-  check(G.redNode(e2) == n4, "Wrong red node");
-  check(G.blueNode(e2) == n2, "Wrong blue node");
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 4);
-  checkGraphArcList(G, 8);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 3);
-  checkGraphIncEdgeArcLists(G, n3, 1);
-  checkGraphIncEdgeArcLists(G, n4, 3);
-
-  checkGraphConEdgeList(G, 4);
-  checkGraphConArcList(G, 8);
-}
-
-
-template <class BpGraph>
-void checkBpGraphSnapshot() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G;
-  RedNode
-    n1 = G.addRedNode();
-  BlueNode
-    n2 = G.addBlueNode(),
-    n3 = G.addBlueNode();
-  Edge
-    e1 = G.addEdge(n1, n2),
-    e2 = G.addEdge(n1, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e2);
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  typename BpGraph::Snapshot snapshot(G);
-
-  RedNode n4 = G.addRedNode();
-  G.addEdge(n4, n2);
-  G.addEdge(n4, n3);
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 4);
-  checkGraphArcList(G, 8);
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  checkGraphIncEdgeArcLists(G, n1, 2);
-  checkGraphIncEdgeArcLists(G, n2, 1);
-  checkGraphIncEdgeArcLists(G, n3, 1);
-
-  checkGraphConEdgeList(G, 2);
-  checkGraphConArcList(G, 4);
-
-  checkNodeIds(G);
-  checkRedNodeIds(G);
-  checkBlueNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-
-  checkGraphNodeMap(G);
-  checkGraphRedNodeMap(G);
-  checkGraphBlueNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-
-  G.addRedNode();
-  snapshot.save(G);
-
-  G.addEdge(G.addRedNode(), G.addBlueNode());
-
-  snapshot.restore();
-  snapshot.save(G);
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  G.addEdge(G.addRedNode(), G.addBlueNode());
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-}
-
-template <typename BpGraph>
-void checkBpGraphValidity() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-  BpGraph g;
-
-  RedNode
-    n1 = g.addRedNode();
-  BlueNode
-    n2 = g.addBlueNode(),
-    n3 = g.addBlueNode();
-
-  Edge
-    e1 = g.addEdge(n1, n2),
-    e2 = g.addEdge(n1, n3);
-  ::lemon::ignore_unused_variable_warning(e2);
-
-  check(g.valid(n1), "Wrong validity check");
-  check(g.valid(e1), "Wrong validity check");
-  check(g.valid(g.direct(e1, true)), "Wrong validity check");
-
-  check(!g.valid(g.nodeFromId(-1)), "Wrong validity check");
-  check(!g.valid(g.edgeFromId(-1)), "Wrong validity check");
-  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");
-}
-
-void checkConcepts() {
-  { // Checking graph components
-    checkConcept<BaseBpGraphComponent, BaseBpGraphComponent >();
-
-    checkConcept<IDableBpGraphComponent<>,
-      IDableBpGraphComponent<> >();
-
-    checkConcept<IterableBpGraphComponent<>,
-      IterableBpGraphComponent<> >();
-
-    checkConcept<AlterableBpGraphComponent<>,
-      AlterableBpGraphComponent<> >();
-
-    checkConcept<MappableBpGraphComponent<>,
-      MappableBpGraphComponent<> >();
-
-    checkConcept<ExtendableBpGraphComponent<>,
-      ExtendableBpGraphComponent<> >();
-
-    checkConcept<ErasableBpGraphComponent<>,
-      ErasableBpGraphComponent<> >();
-
-    checkConcept<ClearableBpGraphComponent<>,
-      ClearableBpGraphComponent<> >();
-
-  }
-  { // Checking skeleton graph
-    checkConcept<BpGraph, BpGraph>();
-  }
-  { // Checking SmartBpGraph
-    checkConcept<BpGraph, SmartBpGraph>();
-    checkConcept<AlterableBpGraphComponent<>, SmartBpGraph>();
-    checkConcept<ExtendableBpGraphComponent<>, SmartBpGraph>();
-    checkConcept<ClearableBpGraphComponent<>, SmartBpGraph>();
-  }
-}
-
-void checkFullBpGraph(int redNum, int blueNum) {
-  typedef FullBpGraph BpGraph;
-  BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G(redNum, blueNum);
-  checkGraphNodeList(G, redNum + blueNum);
-  checkGraphRedNodeList(G, redNum);
-  checkGraphBlueNodeList(G, blueNum);
-  checkGraphEdgeList(G, redNum * blueNum);
-  checkGraphArcList(G, 2 * redNum * blueNum);
-
-  G.resize(redNum, blueNum);
-  checkGraphNodeList(G, redNum + blueNum);
-  checkGraphRedNodeList(G, redNum);
-  checkGraphBlueNodeList(G, blueNum);
-  checkGraphEdgeList(G, redNum * blueNum);
-  checkGraphArcList(G, 2 * redNum * blueNum);
-
-  for (RedNodeIt n(G); n != INVALID; ++n) {
-    checkGraphOutArcList(G, n, blueNum);
-    checkGraphInArcList(G, n, blueNum);
-    checkGraphIncEdgeList(G, n, blueNum);
-  }
-
-  for (BlueNodeIt n(G); n != INVALID; ++n) {
-    checkGraphOutArcList(G, n, redNum);
-    checkGraphInArcList(G, n, redNum);
-    checkGraphIncEdgeList(G, n, redNum);
-  }
-
-  checkGraphConArcList(G, 2 * redNum * blueNum);
-  checkGraphConEdgeList(G, redNum * blueNum);
-
-  checkArcDirections(G);
-
-  checkNodeIds(G);
-  checkRedNodeIds(G);
-  checkBlueNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-
-  checkGraphNodeMap(G);
-  checkGraphRedNodeMap(G);
-  checkGraphBlueNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-
-  for (int i = 0; i < G.redNum(); ++i) {
-    check(G.red(G.redNode(i)), "Wrong node");
-    check(G.index(G.redNode(i)) == i, "Wrong index");
-  }
-
-  for (int i = 0; i < G.blueNum(); ++i) {
-    check(G.blue(G.blueNode(i)), "Wrong node");
-    check(G.index(G.blueNode(i)) == i, "Wrong index");
-  }
-
-  for (NodeIt u(G); u != INVALID; ++u) {
-    for (NodeIt v(G); v != INVALID; ++v) {
-      Edge e = G.edge(u, v);
-      Arc a = G.arc(u, v);
-      if (G.red(u) == G.red(v)) {
-        check(e == INVALID, "Wrong edge lookup");
-        check(a == INVALID, "Wrong arc lookup");
-      } else {
-        check((G.u(e) == u && G.v(e) == v) ||
-              (G.u(e) == v && G.v(e) == u), "Wrong edge lookup");
-        check(G.source(a) == u && G.target(a) == v, "Wrong arc lookup");
-      }
-    }
-  }
-
-}
-
-void checkGraphs() {
-  { // Checking ListGraph
-    checkBpGraphBuild<ListBpGraph>();
-    checkBpGraphErase<ListBpGraph>();
-    checkBpGraphAlter<ListBpGraph>();
-    checkBpGraphSnapshot<ListBpGraph>();
-    checkBpGraphValidity<ListBpGraph>();
-  }
-  { // Checking SmartGraph
-    checkBpGraphBuild<SmartBpGraph>();
-    checkBpGraphSnapshot<SmartBpGraph>();
-    checkBpGraphValidity<SmartBpGraph>();
-  }
-  { // Checking FullBpGraph
-    checkFullBpGraph(6, 8);
-    checkFullBpGraph(7, 4);
-  }
-}
-
-int main() {
-  checkConcepts();
-  checkGraphs();
-  return 0;
-}
Index: test/circulation_test.cc
===================================================================
--- test/circulation_test.cc	(revision 1270)
+++ test/circulation_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/connectivity_test.cc
===================================================================
--- test/connectivity_test.cc	(revision 1270)
+++ test/connectivity_test.cc	(revision 1268)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 1270)
+++ test/dfs_test.cc	(revision 1263)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2011
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/digraph_test.cc
===================================================================
--- test/digraph_test.cc	(revision 1270)
+++ test/digraph_test.cc	(revision 1260)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 1270)
+++ test/dijkstra_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/edge_set_test.cc
===================================================================
--- test/edge_set_test.cc	(revision 1270)
+++ test/edge_set_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/euler_test.cc
===================================================================
--- test/euler_test.cc	(revision 1270)
+++ test/euler_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -103,5 +103,5 @@
     Digraph::Node n = d.addNode();
     ::lemon::ignore_unused_variable_warning(n);
-
+  
     checkDiEulerIt(d);
     checkDiEulerIt(g);
Index: test/fractional_matching_test.cc
===================================================================
--- test/fractional_matching_test.cc	(revision 1270)
+++ test/fractional_matching_test.cc	(revision 1260)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/gomory_hu_test.cc
===================================================================
--- test/gomory_hu_test.cc	(revision 1270)
+++ test/gomory_hu_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 1270)
+++ test/graph_copy_test.cc	(revision 1081)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2011
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,5 +19,4 @@
 #include <lemon/smart_graph.h>
 #include <lemon/list_graph.h>
-#include <lemon/static_graph.h>
 #include <lemon/lgf_reader.h>
 #include <lemon/error.h>
@@ -28,5 +27,4 @@
 using namespace lemon;
 
-template <typename GR>
 void digraph_copy_test() {
   const int nn = 10;
@@ -56,15 +54,15 @@
 
   // Test digraph copy
-  GR to;
-  typename GR::template NodeMap<int> tnm(to);
-  typename GR::template ArcMap<int> tam(to);
-  typename GR::Node tn;
-  typename GR::Arc ta;
-
-  SmartDigraph::NodeMap<typename GR::Node> nr(from);
-  SmartDigraph::ArcMap<typename GR::Arc> er(from);
-
-  typename GR::template NodeMap<SmartDigraph::Node> ncr(to);
-  typename GR::template ArcMap<SmartDigraph::Arc> ecr(to);
+  ListDigraph to;
+  ListDigraph::NodeMap<int> tnm(to);
+  ListDigraph::ArcMap<int> tam(to);
+  ListDigraph::Node tn;
+  ListDigraph::Arc ta;
+
+  SmartDigraph::NodeMap<ListDigraph::Node> nr(from);
+  SmartDigraph::ArcMap<ListDigraph::Arc> er(from);
+
+  ListDigraph::NodeMap<SmartDigraph::Node> ncr(to);
+  ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);
 
   digraphCopy(from, to).
@@ -89,9 +87,9 @@
   }
 
-  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
+  for (ListDigraph::NodeIt it(to); it != INVALID; ++it) {
     check(nr[ncr[it]] == it, "Wrong copy.");
   }
 
-  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
+  for (ListDigraph::ArcIt it(to); it != INVALID; ++it) {
     check(er[ecr[it]] == it, "Wrong copy.");
   }
@@ -106,5 +104,4 @@
 }
 
-template <typename GR>
 void graph_copy_test() {
   const int nn = 10;
@@ -139,19 +136,19 @@
 
   // Test graph copy
-  GR to;
-  typename GR::template NodeMap<int> tnm(to);
-  typename GR::template ArcMap<int> tam(to);
-  typename GR::template EdgeMap<int> tem(to);
-  typename GR::Node tn;
-  typename GR::Arc ta;
-  typename GR::Edge te;
-
-  SmartGraph::NodeMap<typename GR::Node> nr(from);
-  SmartGraph::ArcMap<typename GR::Arc> ar(from);
-  SmartGraph::EdgeMap<typename GR::Edge> er(from);
-
-  typename GR::template NodeMap<SmartGraph::Node> ncr(to);
-  typename GR::template ArcMap<SmartGraph::Arc> acr(to);
-  typename GR::template EdgeMap<SmartGraph::Edge> ecr(to);
+  ListGraph to;
+  ListGraph::NodeMap<int> tnm(to);
+  ListGraph::ArcMap<int> tam(to);
+  ListGraph::EdgeMap<int> tem(to);
+  ListGraph::Node tn;
+  ListGraph::Arc ta;
+  ListGraph::Edge te;
+
+  SmartGraph::NodeMap<ListGraph::Node> nr(from);
+  SmartGraph::ArcMap<ListGraph::Arc> ar(from);
+  SmartGraph::EdgeMap<ListGraph::Edge> er(from);
+
+  ListGraph::NodeMap<SmartGraph::Node> ncr(to);
+  ListGraph::ArcMap<SmartGraph::Arc> acr(to);
+  ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);
 
   graphCopy(from, to).
@@ -188,12 +185,12 @@
   }
 
-  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
+  for (ListGraph::NodeIt it(to); it != INVALID; ++it) {
     check(nr[ncr[it]] == it, "Wrong copy.");
   }
 
-  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
+  for (ListGraph::ArcIt it(to); it != INVALID; ++it) {
     check(ar[acr[it]] == it, "Wrong copy.");
   }
-  for (typename GR::EdgeIt it(to); it != INVALID; ++it) {
+  for (ListGraph::EdgeIt it(to); it != INVALID; ++it) {
     check(er[ecr[it]] == it, "Wrong copy.");
   }
@@ -210,178 +207,8 @@
 }
 
-template <typename GR>
-void bpgraph_copy_test() {
-  const int nn = 10;
-
-  // Build a graph
-  SmartBpGraph from;
-  SmartBpGraph::NodeMap<int> fnm(from);
-  SmartBpGraph::RedNodeMap<int> frnm(from);
-  SmartBpGraph::BlueNodeMap<int> fbnm(from);
-  SmartBpGraph::ArcMap<int> fam(from);
-  SmartBpGraph::EdgeMap<int> fem(from);
-  SmartBpGraph::Node fn = INVALID;
-  SmartBpGraph::RedNode frn = INVALID;
-  SmartBpGraph::BlueNode fbn = INVALID;
-  SmartBpGraph::Arc fa = INVALID;
-  SmartBpGraph::Edge fe = INVALID;
-
-  std::vector<SmartBpGraph::RedNode> frnv;
-  for (int i = 0; i < nn; ++i) {
-    SmartBpGraph::RedNode node = from.addRedNode();
-    frnv.push_back(node);
-    fnm[node] = i * i;
-    frnm[node] = i + i;
-    if (i == 0) {
-      fn = node;
-      frn = node;
-    }
-  }
-
-  std::vector<SmartBpGraph::BlueNode> fbnv;
-  for (int i = 0; i < nn; ++i) {
-    SmartBpGraph::BlueNode node = from.addBlueNode();
-    fbnv.push_back(node);
-    fnm[node] = i * i;
-    fbnm[node] = i + i;
-    if (i == 0) fbn = node;
-  }
-
-  for (int i = 0; i < nn; ++i) {
-    for (int j = 0; j < nn; ++j) {
-      SmartBpGraph::Edge edge = from.addEdge(frnv[i], fbnv[j]);
-      fem[edge] = i * i + j * j;
-      fam[from.direct(edge, true)] = i + j * j;
-      fam[from.direct(edge, false)] = i * i + j;
-      if (i == 0 && j == 0) fa = from.direct(edge, true);
-      if (i == 0 && j == 0) fe = edge;
-    }
-  }
-
-  // Test graph copy
-  GR to;
-  typename GR::template NodeMap<int> tnm(to);
-  typename GR::template RedNodeMap<int> trnm(to);
-  typename GR::template BlueNodeMap<int> tbnm(to);
-  typename GR::template ArcMap<int> tam(to);
-  typename GR::template EdgeMap<int> tem(to);
-  typename GR::Node tn;
-  typename GR::RedNode trn;
-  typename GR::BlueNode tbn;
-  typename GR::Arc ta;
-  typename GR::Edge te;
-
-  SmartBpGraph::NodeMap<typename GR::Node> nr(from);
-  SmartBpGraph::RedNodeMap<typename GR::RedNode> rnr(from);
-  SmartBpGraph::BlueNodeMap<typename GR::BlueNode> bnr(from);
-  SmartBpGraph::ArcMap<typename GR::Arc> ar(from);
-  SmartBpGraph::EdgeMap<typename GR::Edge> er(from);
-
-  typename GR::template NodeMap<SmartBpGraph::Node> ncr(to);
-  typename GR::template RedNodeMap<SmartBpGraph::RedNode> rncr(to);
-  typename GR::template BlueNodeMap<SmartBpGraph::BlueNode> bncr(to);
-  typename GR::template ArcMap<SmartBpGraph::Arc> acr(to);
-  typename GR::template EdgeMap<SmartBpGraph::Edge> ecr(to);
-
-  bpGraphCopy(from, to).
-    nodeMap(fnm, tnm).
-    redNodeMap(frnm, trnm).blueNodeMap(fbnm, tbnm).
-    arcMap(fam, tam).edgeMap(fem, tem).
-    nodeRef(nr).redRef(rnr).blueRef(bnr).
-    arcRef(ar).edgeRef(er).
-    nodeCrossRef(ncr).redCrossRef(rncr).blueCrossRef(bncr).
-    arcCrossRef(acr).edgeCrossRef(ecr).
-    node(fn, tn).redNode(frn, trn).blueNode(fbn, tbn).
-    arc(fa, ta).edge(fe, te).run();
-
-  check(countNodes(from) == countNodes(to), "Wrong copy.");
-  check(countRedNodes(from) == countRedNodes(to), "Wrong copy.");
-  check(countBlueNodes(from) == countBlueNodes(to), "Wrong copy.");
-  check(countEdges(from) == countEdges(to), "Wrong copy.");
-  check(countArcs(from) == countArcs(to), "Wrong copy.");
-
-  for (SmartBpGraph::NodeIt it(from); it != INVALID; ++it) {
-    check(ncr[nr[it]] == it, "Wrong copy.");
-    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
-  }
-
-  for (SmartBpGraph::RedNodeIt it(from); it != INVALID; ++it) {
-    check(ncr[nr[it]] == it, "Wrong copy.");
-    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
-    check(rnr[it] == nr[it], "Wrong copy.");
-    check(rncr[rnr[it]] == it, "Wrong copy.");
-    check(frnm[it] == trnm[rnr[it]], "Wrong copy.");
-    check(to.red(rnr[it]), "Wrong copy.");
-  }
-
-  for (SmartBpGraph::BlueNodeIt it(from); it != INVALID; ++it) {
-    check(ncr[nr[it]] == it, "Wrong copy.");
-    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
-    check(bnr[it] == nr[it], "Wrong copy.");
-    check(bncr[bnr[it]] == it, "Wrong copy.");
-    check(fbnm[it] == tbnm[bnr[it]], "Wrong copy.");
-    check(to.blue(bnr[it]), "Wrong copy.");
-  }
-
-  for (SmartBpGraph::ArcIt it(from); it != INVALID; ++it) {
-    check(acr[ar[it]] == it, "Wrong copy.");
-    check(fam[it] == tam[ar[it]], "Wrong copy.");
-    check(nr[from.source(it)] == to.source(ar[it]), "Wrong copy.");
-    check(nr[from.target(it)] == to.target(ar[it]), "Wrong copy.");
-  }
-
-  for (SmartBpGraph::EdgeIt it(from); it != INVALID; ++it) {
-    check(ecr[er[it]] == it, "Wrong copy.");
-    check(fem[it] == tem[er[it]], "Wrong copy.");
-    check(nr[from.u(it)] == to.u(er[it]) || nr[from.u(it)] == to.v(er[it]),
-          "Wrong copy.");
-    check(nr[from.v(it)] == to.u(er[it]) || nr[from.v(it)] == to.v(er[it]),
-          "Wrong copy.");
-    check((from.u(it) != from.v(it)) == (to.u(er[it]) != to.v(er[it])),
-          "Wrong copy.");
-  }
-
-  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
-    check(nr[ncr[it]] == it, "Wrong copy.");
-  }
-  for (typename GR::RedNodeIt it(to); it != INVALID; ++it) {
-    check(rncr[it] == ncr[it], "Wrong copy.");
-    check(rnr[rncr[it]] == it, "Wrong copy.");
-  }
-  for (typename GR::BlueNodeIt it(to); it != INVALID; ++it) {
-    check(bncr[it] == ncr[it], "Wrong copy.");
-    check(bnr[bncr[it]] == it, "Wrong copy.");
-  }
-  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
-    check(ar[acr[it]] == it, "Wrong copy.");
-  }
-  for (typename GR::EdgeIt it(to); it != INVALID; ++it) {
-    check(er[ecr[it]] == it, "Wrong copy.");
-  }
-  check(tn == nr[fn], "Wrong copy.");
-  check(trn == rnr[frn], "Wrong copy.");
-  check(tbn == bnr[fbn], "Wrong copy.");
-  check(ta == ar[fa], "Wrong copy.");
-  check(te == er[fe], "Wrong copy.");
-
-  // Test repeated copy
-  bpGraphCopy(from, to).run();
-
-  check(countNodes(from) == countNodes(to), "Wrong copy.");
-  check(countRedNodes(from) == countRedNodes(to), "Wrong copy.");
-  check(countBlueNodes(from) == countBlueNodes(to), "Wrong copy.");
-  check(countEdges(from) == countEdges(to), "Wrong copy.");
-  check(countArcs(from) == countArcs(to), "Wrong copy.");
-}
-
 
 int main() {
-  digraph_copy_test<SmartDigraph>();
-  digraph_copy_test<ListDigraph>();
-  digraph_copy_test<StaticDigraph>();
-  graph_copy_test<SmartGraph>();
-  graph_copy_test<ListGraph>();
-  bpgraph_copy_test<SmartBpGraph>();
-  bpgraph_copy_test<ListBpGraph>();
+  digraph_copy_test();
+  graph_copy_test();
 
   return 0;
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 1270)
+++ test/graph_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/graph_test.h
===================================================================
--- test/graph_test.h	(revision 1270)
+++ test/graph_test.h	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,40 +39,4 @@
     check(n==INVALID,"Wrong Node list linking.");
     check(countNodes(G)==cnt,"Wrong Node number.");
-  }
-
-  template<class Graph>
-  void checkGraphRedNodeList(const Graph &G, int cnt)
-  {
-    typename Graph::RedNodeIt n(G);
-    for(int i=0;i<cnt;i++) {
-      check(n!=INVALID,"Wrong red Node list linking.");
-      check(G.red(n),"Wrong node set check.");
-      check(!G.blue(n),"Wrong node set check.");
-      typename Graph::Node nn = n;
-      check(G.asRedNodeUnsafe(nn) == n,"Wrong node conversion.");
-      check(G.asRedNode(nn) == n,"Wrong node conversion.");
-      check(G.asBlueNode(nn) == INVALID,"Wrong node conversion.");
-      ++n;
-    }
-    check(n==INVALID,"Wrong red Node list linking.");
-    check(countRedNodes(G)==cnt,"Wrong red Node number.");
-  }
-
-  template<class Graph>
-  void checkGraphBlueNodeList(const Graph &G, int cnt)
-  {
-    typename Graph::BlueNodeIt n(G);
-    for(int i=0;i<cnt;i++) {
-      check(n!=INVALID,"Wrong blue Node list linking.");
-      check(G.blue(n),"Wrong node set check.");
-      check(!G.red(n),"Wrong node set check.");
-      typename Graph::Node nn = n;
-      check(G.asBlueNodeUnsafe(nn) == n,"Wrong node conversion.");
-      check(G.asBlueNode(nn) == n,"Wrong node conversion.");
-      check(G.asRedNode(nn) == INVALID,"Wrong node conversion.");
-      ++n;
-    }
-    check(n==INVALID,"Wrong blue Node list linking.");
-    check(countBlueNodes(G)==cnt,"Wrong blue Node number.");
   }
 
@@ -203,5 +167,4 @@
   template <typename Graph>
   void checkNodeIds(const Graph& G) {
-    typedef typename Graph::Node Node;
     std::set<int> values;
     for (typename Graph::NodeIt n(G); n != INVALID; ++n) {
@@ -211,36 +174,8 @@
       values.insert(G.id(n));
     }
-    check(G.maxId(Node()) <= G.maxNodeId(), "Wrong maximum id");
-  }
-
-  template <typename Graph>
-  void checkRedNodeIds(const Graph& G) {
-    typedef typename Graph::RedNode RedNode;
-    std::set<int> values;
-    for (typename Graph::RedNodeIt n(G); n != INVALID; ++n) {
-      check(G.red(n), "Wrong partition");
-      check(values.find(G.id(n)) == values.end(), "Wrong id");
-      check(G.id(n) <= G.maxRedId(), "Wrong maximum id");
-      values.insert(G.id(n));
-    }
-    check(G.maxId(RedNode()) == G.maxRedId(), "Wrong maximum id");
-  }
-
-  template <typename Graph>
-  void checkBlueNodeIds(const Graph& G) {
-    typedef typename Graph::BlueNode BlueNode;
-    std::set<int> values;
-    for (typename Graph::BlueNodeIt n(G); n != INVALID; ++n) {
-      check(G.blue(n), "Wrong partition");
-      check(values.find(G.id(n)) == values.end(), "Wrong id");
-      check(G.id(n) <= G.maxBlueId(), "Wrong maximum id");
-      values.insert(G.id(n));
-    }
-    check(G.maxId(BlueNode()) == G.maxBlueId(), "Wrong maximum id");
   }
 
   template <typename Graph>
   void checkArcIds(const Graph& G) {
-    typedef typename Graph::Arc Arc;
     std::set<int> values;
     for (typename Graph::ArcIt a(G); a != INVALID; ++a) {
@@ -250,10 +185,8 @@
       values.insert(G.id(a));
     }
-    check(G.maxId(Arc()) <= G.maxArcId(), "Wrong maximum id");
   }
 
   template <typename Graph>
   void checkEdgeIds(const Graph& G) {
-    typedef typename Graph::Edge Edge;
     std::set<int> values;
     for (typename Graph::EdgeIt e(G); e != INVALID; ++e) {
@@ -263,5 +196,4 @@
       values.insert(G.id(e));
     }
-    check(G.maxId(Edge()) <= G.maxEdgeId(), "Wrong maximum id");
   }
 
@@ -297,64 +229,4 @@
 
   template <typename Graph>
-  void checkGraphRedNodeMap(const Graph& G) {
-    typedef typename Graph::Node Node;
-    typedef typename Graph::RedNodeIt RedNodeIt;
-
-    typedef typename Graph::template RedNodeMap<int> IntRedNodeMap;
-    IntRedNodeMap map(G, 42);
-    for (RedNodeIt it(G); it != INVALID; ++it) {
-      check(map[it] == 42, "Wrong map constructor.");
-    }
-    int s = 0;
-    for (RedNodeIt it(G); it != INVALID; ++it) {
-      map[it] = 0;
-      check(map[it] == 0, "Wrong operator[].");
-      map.set(it, s);
-      check(map[it] == s, "Wrong set.");
-      ++s;
-    }
-    s = s * (s - 1) / 2;
-    for (RedNodeIt it(G); it != INVALID; ++it) {
-      s -= map[it];
-    }
-    check(s == 0, "Wrong sum.");
-
-    // map = constMap<Node>(12);
-    // for (NodeIt it(G); it != INVALID; ++it) {
-    //   check(map[it] == 12, "Wrong operator[].");
-    // }
-  }
-
-  template <typename Graph>
-  void checkGraphBlueNodeMap(const Graph& G) {
-    typedef typename Graph::Node Node;
-    typedef typename Graph::BlueNodeIt BlueNodeIt;
-
-    typedef typename Graph::template BlueNodeMap<int> IntBlueNodeMap;
-    IntBlueNodeMap map(G, 42);
-    for (BlueNodeIt it(G); it != INVALID; ++it) {
-      check(map[it] == 42, "Wrong map constructor.");
-    }
-    int s = 0;
-    for (BlueNodeIt it(G); it != INVALID; ++it) {
-      map[it] = 0;
-      check(map[it] == 0, "Wrong operator[].");
-      map.set(it, s);
-      check(map[it] == s, "Wrong set.");
-      ++s;
-    }
-    s = s * (s - 1) / 2;
-    for (BlueNodeIt it(G); it != INVALID; ++it) {
-      s -= map[it];
-    }
-    check(s == 0, "Wrong sum.");
-
-    // map = constMap<Node>(12);
-    // for (NodeIt it(G); it != INVALID; ++it) {
-    //   check(map[it] == 12, "Wrong operator[].");
-    // }
-  }
-
-  template <typename Graph>
   void checkGraphArcMap(const Graph& G) {
     typedef typename Graph::Arc Arc;
Index: test/hao_orlin_test.cc
===================================================================
--- test/hao_orlin_test.cc	(revision 1270)
+++ test/hao_orlin_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/heap_test.cc
===================================================================
--- test/heap_test.cc	(revision 1270)
+++ test/heap_test.cc	(revision 1084)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2011
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/lgf_reader_writer_test.cc
===================================================================
--- test/lgf_reader_writer_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,578 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * 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 <string>
-
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/bpgraph.h>
-
-#include <lemon/list_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/lgf_reader.h>
-
-#include "test_tools.h"
-
-struct ReaderConverter {
-  int operator()(const std::string& str) const {
-    return str.length();
-  }
-};
-
-struct WriterConverter {
-  std::string operator()(int value) const {
-    return std::string(value, '*');
-  }
-};
-
-void checkDigraphReaderCompile() {
-  typedef lemon::concepts::ExtendableDigraphComponent<
-    lemon::concepts::Digraph> Digraph;
-  Digraph digraph;
-  Digraph::NodeMap<int> node_map(digraph);
-  Digraph::ArcMap<int> arc_map(digraph);
-  Digraph::Node node;
-  Digraph::Arc arc;
-  int attr;
-
-  lemon::DigraphReader<Digraph> reader(digraph, "filename");
-  reader.nodeMap("node_map", node_map);
-  reader.nodeMap("node_map", node_map, ReaderConverter());
-  reader.arcMap("arc_map", arc_map);
-  reader.arcMap("arc_map", arc_map, ReaderConverter());
-  reader.attribute("attr", attr);
-  reader.attribute("attr", attr, ReaderConverter());
-  reader.node("node", node);
-  reader.arc("arc", arc);
-
-  reader.nodes("alt_nodes_caption");
-  reader.arcs("alt_arcs_caption");
-  reader.attributes("alt_attrs_caption");
-
-  reader.useNodes(node_map);
-  reader.useNodes(node_map, WriterConverter());
-  reader.useArcs(arc_map);
-  reader.useArcs(arc_map, WriterConverter());
-
-  reader.skipNodes();
-  reader.skipArcs();
-
-  reader.run();
-
-  lemon::DigraphReader<Digraph> reader2(digraph, std::cin);
-}
-
-void checkDigraphWriterCompile() {
-  typedef lemon::concepts::Digraph Digraph;
-  Digraph digraph;
-  Digraph::NodeMap<int> node_map(digraph);
-  Digraph::ArcMap<int> arc_map(digraph);
-  Digraph::Node node;
-  Digraph::Arc arc;
-  int attr;
-
-  lemon::DigraphWriter<Digraph> writer(digraph, "filename");
-  writer.nodeMap("node_map", node_map);
-  writer.nodeMap("node_map", node_map, WriterConverter());
-  writer.arcMap("arc_map", arc_map);
-  writer.arcMap("arc_map", arc_map, WriterConverter());
-  writer.attribute("attr", attr);
-  writer.attribute("attr", attr, WriterConverter());
-  writer.node("node", node);
-  writer.arc("arc", arc);
-
-  writer.nodes("alt_nodes_caption");
-  writer.arcs("alt_arcs_caption");
-  writer.attributes("alt_attrs_caption");
-
-  writer.skipNodes();
-  writer.skipArcs();
-
-  writer.run();
-}
-
-void checkGraphReaderCompile() {
-  typedef lemon::concepts::ExtendableGraphComponent<
-    lemon::concepts::Graph> Graph;
-  Graph graph;
-  Graph::NodeMap<int> node_map(graph);
-  Graph::ArcMap<int> arc_map(graph);
-  Graph::EdgeMap<int> edge_map(graph);
-  Graph::Node node;
-  Graph::Arc arc;
-  Graph::Edge edge;
-  int attr;
-
-  lemon::GraphReader<Graph> reader(graph, "filename");
-  reader.nodeMap("node_map", node_map);
-  reader.nodeMap("node_map", node_map, ReaderConverter());
-  reader.arcMap("arc_map", arc_map);
-  reader.arcMap("arc_map", arc_map, ReaderConverter());
-  reader.edgeMap("edge_map", edge_map);
-  reader.edgeMap("edge_map", edge_map, ReaderConverter());
-  reader.attribute("attr", attr);
-  reader.attribute("attr", attr, ReaderConverter());
-  reader.node("node", node);
-  reader.arc("arc", arc);
-
-  reader.nodes("alt_nodes_caption");
-  reader.edges("alt_edges_caption");
-  reader.attributes("alt_attrs_caption");
-
-  reader.useNodes(node_map);
-  reader.useNodes(node_map, WriterConverter());
-  reader.useEdges(edge_map);
-  reader.useEdges(edge_map, WriterConverter());
-
-  reader.skipNodes();
-  reader.skipEdges();
-
-  reader.run();
-
-  lemon::GraphReader<Graph> reader2(graph, std::cin);
-}
-
-void checkGraphWriterCompile() {
-  typedef lemon::concepts::Graph Graph;
-  Graph graph;
-  Graph::NodeMap<int> node_map(graph);
-  Graph::ArcMap<int> arc_map(graph);
-  Graph::EdgeMap<int> edge_map(graph);
-  Graph::Node node;
-  Graph::Arc arc;
-  Graph::Edge edge;
-  int attr;
-
-  lemon::GraphWriter<Graph> writer(graph, "filename");
-  writer.nodeMap("node_map", node_map);
-  writer.nodeMap("node_map", node_map, WriterConverter());
-  writer.arcMap("arc_map", arc_map);
-  writer.arcMap("arc_map", arc_map, WriterConverter());
-  writer.edgeMap("edge_map", edge_map);
-  writer.edgeMap("edge_map", edge_map, WriterConverter());
-  writer.attribute("attr", attr);
-  writer.attribute("attr", attr, WriterConverter());
-  writer.node("node", node);
-  writer.arc("arc", arc);
-  writer.edge("edge", edge);
-
-  writer.nodes("alt_nodes_caption");
-  writer.edges("alt_edges_caption");
-  writer.attributes("alt_attrs_caption");
-
-  writer.skipNodes();
-  writer.skipEdges();
-
-  writer.run();
-
-  lemon::GraphWriter<Graph> writer2(graph, std::cout);
-}
-
-void checkBpGraphReaderCompile() {
-  typedef lemon::concepts::ExtendableBpGraphComponent<
-    lemon::concepts::BpGraph> BpGraph;
-  BpGraph graph;
-  BpGraph::NodeMap<int> node_map(graph);
-  BpGraph::RedNodeMap<int> red_node_map(graph);
-  BpGraph::BlueNodeMap<int> blue_node_map(graph);
-  BpGraph::ArcMap<int> arc_map(graph);
-  BpGraph::EdgeMap<int> edge_map(graph);
-  BpGraph::Node node;
-  BpGraph::RedNode red_node;
-  BpGraph::BlueNode blue_node;
-  BpGraph::Arc arc;
-  BpGraph::Edge edge;
-  int attr;
-
-  lemon::BpGraphReader<BpGraph> reader(graph, "filename");
-  reader.nodeMap("node_map", node_map);
-  reader.nodeMap("node_map", node_map, ReaderConverter());
-  reader.redNodeMap("red_node_map", red_node_map);
-  reader.redNodeMap("red_node_map", red_node_map, ReaderConverter());
-  reader.blueNodeMap("blue_node_map", blue_node_map);
-  reader.blueNodeMap("blue_node_map", blue_node_map, ReaderConverter());
-  reader.arcMap("arc_map", arc_map);
-  reader.arcMap("arc_map", arc_map, ReaderConverter());
-  reader.edgeMap("edge_map", edge_map);
-  reader.edgeMap("edge_map", edge_map, ReaderConverter());
-  reader.attribute("attr", attr);
-  reader.attribute("attr", attr, ReaderConverter());
-  reader.node("node", node);
-  reader.redNode("red_node", red_node);
-  reader.blueNode("blue_node", blue_node);
-  reader.arc("arc", arc);
-
-  reader.nodes("alt_nodes_caption");
-  reader.edges("alt_edges_caption");
-  reader.attributes("alt_attrs_caption");
-
-  reader.useNodes(node_map);
-  reader.useNodes(node_map, WriterConverter());
-  reader.useEdges(edge_map);
-  reader.useEdges(edge_map, WriterConverter());
-
-  reader.skipNodes();
-  reader.skipEdges();
-
-  reader.run();
-
-  lemon::BpGraphReader<BpGraph> reader2(graph, std::cin);
-}
-
-void checkBpGraphWriterCompile() {
-  typedef lemon::concepts::BpGraph BpGraph;
-  BpGraph graph;
-  BpGraph::NodeMap<int> node_map(graph);
-  BpGraph::RedNodeMap<int> red_node_map(graph);
-  BpGraph::BlueNodeMap<int> blue_node_map(graph);
-  BpGraph::ArcMap<int> arc_map(graph);
-  BpGraph::EdgeMap<int> edge_map(graph);
-  BpGraph::Node node;
-  BpGraph::RedNode red_node;
-  BpGraph::BlueNode blue_node;
-  BpGraph::Arc arc;
-  BpGraph::Edge edge;
-  int attr;
-
-  lemon::BpGraphWriter<BpGraph> writer(graph, "filename");
-  writer.nodeMap("node_map", node_map);
-  writer.nodeMap("node_map", node_map, WriterConverter());
-  writer.redNodeMap("red_node_map", red_node_map);
-  writer.redNodeMap("red_node_map", red_node_map, WriterConverter());
-  writer.blueNodeMap("blue_node_map", blue_node_map);
-  writer.blueNodeMap("blue_node_map", blue_node_map, WriterConverter());
-  writer.arcMap("arc_map", arc_map);
-  writer.arcMap("arc_map", arc_map, WriterConverter());
-  writer.edgeMap("edge_map", edge_map);
-  writer.edgeMap("edge_map", edge_map, WriterConverter());
-  writer.attribute("attr", attr);
-  writer.attribute("attr", attr, WriterConverter());
-  writer.node("node", node);
-  writer.redNode("red_node", red_node);
-  writer.blueNode("blue_node", blue_node);
-  writer.arc("arc", arc);
-
-  writer.nodes("alt_nodes_caption");
-  writer.edges("alt_edges_caption");
-  writer.attributes("alt_attrs_caption");
-
-  writer.skipNodes();
-  writer.skipEdges();
-
-  writer.run();
-
-  lemon::BpGraphWriter<BpGraph> writer2(graph, std::cout);
-}
-
-void checkDigraphReaderWriter() {
-  typedef lemon::SmartDigraph Digraph;
-  Digraph digraph;
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Digraph::Node n3 = digraph.addNode();
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n2, n3);
-
-  Digraph::NodeMap<int> node_map(digraph);
-  node_map[n1] = 11;
-  node_map[n2] = 12;
-  node_map[n3] = 13;
-
-  Digraph::ArcMap<int> arc_map(digraph);
-  arc_map[a1] = 21;
-  arc_map[a2] = 22;
-
-  int attr = 100;
-
-  std::ostringstream os;
-  lemon::DigraphWriter<Digraph> writer(digraph, os);
-
-  writer.nodeMap("node_map1", node_map);
-  writer.nodeMap("node_map2", node_map, WriterConverter());
-  writer.arcMap("arc_map1", arc_map);
-  writer.arcMap("arc_map2", arc_map, WriterConverter());
-  writer.node("node", n2);
-  writer.arc("arc", a1);
-  writer.attribute("attr1", attr);
-  writer.attribute("attr2", attr, WriterConverter());
-
-  writer.run();
-
-  typedef lemon::ListDigraph ExpDigraph;
-  ExpDigraph exp_digraph;
-  ExpDigraph::NodeMap<int> exp_node_map1(exp_digraph);
-  ExpDigraph::NodeMap<int> exp_node_map2(exp_digraph);
-  ExpDigraph::ArcMap<int> exp_arc_map1(exp_digraph);
-  ExpDigraph::ArcMap<int> exp_arc_map2(exp_digraph);
-  ExpDigraph::Node exp_n2;
-  ExpDigraph::Arc exp_a1;
-  int exp_attr1;
-  int exp_attr2;
-
-  std::istringstream is(os.str());
-  lemon::DigraphReader<ExpDigraph> reader(exp_digraph, is);
-
-  reader.nodeMap("node_map1", exp_node_map1);
-  reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
-  reader.arcMap("arc_map1", exp_arc_map1);
-  reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
-  reader.node("node", exp_n2);
-  reader.arc("arc", exp_a1);
-  reader.attribute("attr1", exp_attr1);
-  reader.attribute("attr2", exp_attr2, ReaderConverter());
-
-  reader.run();
-
-  check(lemon::countNodes(exp_digraph) == 3, "Wrong number of nodes");
-  check(lemon::countArcs(exp_digraph) == 2, "Wrong number of arcs");
-  check(exp_node_map1[exp_n2] == 12, "Wrong map value");
-  check(exp_node_map2[exp_n2] == 12, "Wrong map value");
-  check(exp_arc_map1[exp_a1] == 21, "Wrong map value");
-  check(exp_arc_map2[exp_a1] == 21, "Wrong map value");
-  check(exp_attr1 == 100, "Wrong attr value");
-  check(exp_attr2 == 100, "Wrong attr value");
-}
-
-void checkGraphReaderWriter() {
-  typedef lemon::SmartGraph Graph;
-  Graph graph;
-  Graph::Node n1 = graph.addNode();
-  Graph::Node n2 = graph.addNode();
-  Graph::Node n3 = graph.addNode();
-
-  Graph::Edge e1 = graph.addEdge(n1, n2);
-  Graph::Edge e2 = graph.addEdge(n2, n3);
-
-  Graph::NodeMap<int> node_map(graph);
-  node_map[n1] = 11;
-  node_map[n2] = 12;
-  node_map[n3] = 13;
-
-  Graph::EdgeMap<int> edge_map(graph);
-  edge_map[e1] = 21;
-  edge_map[e2] = 22;
-
-  Graph::ArcMap<int> arc_map(graph);
-  arc_map[graph.direct(e1, true)] = 211;
-  arc_map[graph.direct(e1, false)] = 212;
-  arc_map[graph.direct(e2, true)] = 221;
-  arc_map[graph.direct(e2, false)] = 222;
-
-  int attr = 100;
-
-  std::ostringstream os;
-  lemon::GraphWriter<Graph> writer(graph, os);
-
-  writer.nodeMap("node_map1", node_map);
-  writer.nodeMap("node_map2", node_map, WriterConverter());
-  writer.edgeMap("edge_map1", edge_map);
-  writer.edgeMap("edge_map2", edge_map, WriterConverter());
-  writer.arcMap("arc_map1", arc_map);
-  writer.arcMap("arc_map2", arc_map, WriterConverter());
-  writer.node("node", n2);
-  writer.edge("edge", e1);
-  writer.arc("arc", graph.direct(e1, false));
-  writer.attribute("attr1", attr);
-  writer.attribute("attr2", attr, WriterConverter());
-
-  writer.run();
-
-  typedef lemon::ListGraph ExpGraph;
-  ExpGraph exp_graph;
-  ExpGraph::NodeMap<int> exp_node_map1(exp_graph);
-  ExpGraph::NodeMap<int> exp_node_map2(exp_graph);
-  ExpGraph::EdgeMap<int> exp_edge_map1(exp_graph);
-  ExpGraph::EdgeMap<int> exp_edge_map2(exp_graph);
-  ExpGraph::ArcMap<int> exp_arc_map1(exp_graph);
-  ExpGraph::ArcMap<int> exp_arc_map2(exp_graph);
-  ExpGraph::Node exp_n2;
-  ExpGraph::Edge exp_e1;
-  ExpGraph::Arc exp_a1;
-  int exp_attr1;
-  int exp_attr2;
-
-  std::istringstream is(os.str());
-  lemon::GraphReader<ExpGraph> reader(exp_graph, is);
-
-  reader.nodeMap("node_map1", exp_node_map1);
-  reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
-  reader.edgeMap("edge_map1", exp_edge_map1);
-  reader.edgeMap("edge_map2", exp_edge_map2, ReaderConverter());
-  reader.arcMap("arc_map1", exp_arc_map1);
-  reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
-  reader.node("node", exp_n2);
-  reader.edge("edge", exp_e1);
-  reader.arc("arc", exp_a1);
-  reader.attribute("attr1", exp_attr1);
-  reader.attribute("attr2", exp_attr2, ReaderConverter());
-
-  reader.run();
-
-  check(lemon::countNodes(exp_graph) == 3, "Wrong number of nodes");
-  check(lemon::countEdges(exp_graph) == 2, "Wrong number of edges");
-  check(lemon::countArcs(exp_graph) == 4, "Wrong number of arcs");
-  check(exp_node_map1[exp_n2] == 12, "Wrong map value");
-  check(exp_node_map2[exp_n2] == 12, "Wrong map value");
-  check(exp_edge_map1[exp_e1] == 21, "Wrong map value");
-  check(exp_edge_map2[exp_e1] == 21, "Wrong map value");
-  check(exp_arc_map1[exp_a1] == 212, "Wrong map value");
-  check(exp_arc_map2[exp_a1] == 212, "Wrong map value");
-  check(exp_attr1 == 100, "Wrong attr value");
-  check(exp_attr2 == 100, "Wrong attr value");
-}
-
-void checkBpGraphReaderWriter() {
-  typedef lemon::SmartBpGraph Graph;
-  Graph graph;
-  Graph::RedNode rn1 = graph.addRedNode();
-  Graph::RedNode rn2 = graph.addRedNode();
-  Graph::RedNode rn3 = graph.addRedNode();
-  Graph::BlueNode bn1 = graph.addBlueNode();
-  Graph::BlueNode bn2 = graph.addBlueNode();
-  Graph::Node n = bn1;
-
-  Graph::Edge e1 = graph.addEdge(rn1, bn1);
-  Graph::Edge e2 = graph.addEdge(rn2, bn1);
-
-  Graph::NodeMap<int> node_map(graph);
-  node_map[rn1] = 11;
-  node_map[rn2] = 12;
-  node_map[rn3] = 13;
-  node_map[bn1] = 14;
-  node_map[bn2] = 15;
-
-  Graph::NodeMap<int> red_node_map(graph);
-  red_node_map[rn1] = 411;
-  red_node_map[rn2] = 412;
-  red_node_map[rn3] = 413;
-
-  Graph::NodeMap<int> blue_node_map(graph);
-  blue_node_map[bn1] = 414;
-  blue_node_map[bn2] = 415;
-
-  Graph::EdgeMap<int> edge_map(graph);
-  edge_map[e1] = 21;
-  edge_map[e2] = 22;
-
-  Graph::ArcMap<int> arc_map(graph);
-  arc_map[graph.direct(e1, true)] = 211;
-  arc_map[graph.direct(e1, false)] = 212;
-  arc_map[graph.direct(e2, true)] = 221;
-  arc_map[graph.direct(e2, false)] = 222;
-
-  int attr = 100;
-
-  std::ostringstream os;
-  lemon::BpGraphWriter<Graph> writer(graph, os);
-
-  writer.nodeMap("node_map1", node_map);
-  writer.nodeMap("node_map2", node_map, WriterConverter());
-  writer.nodeMap("red_node_map1", red_node_map);
-  writer.nodeMap("red_node_map2", red_node_map, WriterConverter());
-  writer.nodeMap("blue_node_map1", blue_node_map);
-  writer.nodeMap("blue_node_map2", blue_node_map, WriterConverter());
-  writer.edgeMap("edge_map1", edge_map);
-  writer.edgeMap("edge_map2", edge_map, WriterConverter());
-  writer.arcMap("arc_map1", arc_map);
-  writer.arcMap("arc_map2", arc_map, WriterConverter());
-  writer.node("node", n);
-  writer.redNode("red_node", rn1);
-  writer.blueNode("blue_node", bn2);
-  writer.edge("edge", e1);
-  writer.arc("arc", graph.direct(e1, false));
-  writer.attribute("attr1", attr);
-  writer.attribute("attr2", attr, WriterConverter());
-
-  writer.run();
-
-  typedef lemon::ListBpGraph ExpGraph;
-  ExpGraph exp_graph;
-  ExpGraph::NodeMap<int> exp_node_map1(exp_graph);
-  ExpGraph::NodeMap<int> exp_node_map2(exp_graph);
-  ExpGraph::RedNodeMap<int> exp_red_node_map1(exp_graph);
-  ExpGraph::RedNodeMap<int> exp_red_node_map2(exp_graph);
-  ExpGraph::BlueNodeMap<int> exp_blue_node_map1(exp_graph);
-  ExpGraph::BlueNodeMap<int> exp_blue_node_map2(exp_graph);
-  ExpGraph::EdgeMap<int> exp_edge_map1(exp_graph);
-  ExpGraph::EdgeMap<int> exp_edge_map2(exp_graph);
-  ExpGraph::ArcMap<int> exp_arc_map1(exp_graph);
-  ExpGraph::ArcMap<int> exp_arc_map2(exp_graph);
-  ExpGraph::Node exp_n;
-  ExpGraph::RedNode exp_rn1;
-  ExpGraph::BlueNode exp_bn2;
-  ExpGraph::Edge exp_e1;
-  ExpGraph::Arc exp_a1;
-  int exp_attr1;
-  int exp_attr2;
-
-  std::istringstream is(os.str());
-  lemon::BpGraphReader<ExpGraph> reader(exp_graph, is);
-
-  reader.nodeMap("node_map1", exp_node_map1);
-  reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
-  reader.redNodeMap("red_node_map1", exp_red_node_map1);
-  reader.redNodeMap("red_node_map2", exp_red_node_map2, ReaderConverter());
-  reader.blueNodeMap("blue_node_map1", exp_blue_node_map1);
-  reader.blueNodeMap("blue_node_map2", exp_blue_node_map2, ReaderConverter());
-  reader.edgeMap("edge_map1", exp_edge_map1);
-  reader.edgeMap("edge_map2", exp_edge_map2, ReaderConverter());
-  reader.arcMap("arc_map1", exp_arc_map1);
-  reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
-  reader.node("node", exp_n);
-  reader.redNode("red_node", exp_rn1);
-  reader.blueNode("blue_node", exp_bn2);
-  reader.edge("edge", exp_e1);
-  reader.arc("arc", exp_a1);
-  reader.attribute("attr1", exp_attr1);
-  reader.attribute("attr2", exp_attr2, ReaderConverter());
-
-  reader.run();
-
-  check(lemon::countNodes(exp_graph) == 5, "Wrong number of nodes");
-  check(lemon::countRedNodes(exp_graph) == 3, "Wrong number of red nodes");
-  check(lemon::countBlueNodes(exp_graph) == 2, "Wrong number of blue nodes");
-  check(lemon::countEdges(exp_graph) == 2, "Wrong number of edges");
-  check(lemon::countArcs(exp_graph) == 4, "Wrong number of arcs");
-  check(exp_node_map1[exp_n] == 14, "Wrong map value");
-  check(exp_node_map2[exp_n] == 14, "Wrong map value");
-  check(exp_red_node_map1[exp_rn1] == 411, "Wrong map value");
-  check(exp_red_node_map2[exp_rn1] == 411, "Wrong map value");
-  check(exp_blue_node_map1[exp_bn2] == 415, "Wrong map value");
-  check(exp_blue_node_map2[exp_bn2] == 415, "Wrong map value");
-  check(exp_edge_map1[exp_e1] == 21, "Wrong map value");
-  check(exp_edge_map2[exp_e1] == 21, "Wrong map value");
-  check(exp_arc_map1[exp_a1] == 212, "Wrong map value");
-  check(exp_arc_map2[exp_a1] == 212, "Wrong map value");
-  check(exp_attr1 == 100, "Wrong attr value");
-  check(exp_attr2 == 100, "Wrong attr value");
-}
-
-
-int main() {
-  { // Check digrpah
-    checkDigraphReaderWriter();
-  }
-  { // Check graph
-    checkGraphReaderWriter();
-  }
-  { // Check bipartite graph
-    checkBpGraphReaderWriter();
-  }
-  return 0;
-}
Index: test/lgf_test.cc
===================================================================
--- test/lgf_test.cc	(revision 1270)
+++ test/lgf_test.cc	(revision 1097)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2011
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 1300)
+++ test/lp_test.cc	(revision 1248)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2011
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -40,7 +40,4 @@
 #endif
 
-#ifdef LEMON_HAVE_LP
-#include <lemon/lp.h>
-#endif
 using namespace lemon;
 
@@ -420,13 +417,4 @@
   lpTest(lp_skel);
 
-#ifdef LEMON_HAVE_LP
-  {
-    Lp lp,lp2;
-    lpTest(lp);
-    aTest(lp2);
-    cloneTest<Lp>();
-  }
-#endif
-
 #ifdef LEMON_HAVE_GLPK
   {
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 1270)
+++ test/maps_test.cc	(revision 1277)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2011
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/matching_test.cc
===================================================================
--- test/matching_test.cc	(revision 1270)
+++ test/matching_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/max_cardinality_search_test.cc
===================================================================
--- test/max_cardinality_search_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,162 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * 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 "test_tools.h"
-#include <lemon/smart_graph.h>
-#include <lemon/max_cardinality_search.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concepts/heap.h>
-#include <lemon/lgf_reader.h>
-
-using namespace lemon;
-using namespace std;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "@arcs\n"
-  "    label capacity\n"
-  "0 1 0     2\n"
-  "1 0 1     2\n"
-  "2 1 2     1\n"
-  "2 3 3     3\n"
-  "3 2 4     3\n"
-  "3 1 5     5\n"
-  "@attributes\n"
-  "s 0\n"
-  "x 1\n"
-  "y 2\n"
-  "z 3\n";
-
-void checkMaxCardSearchCompile() {
-
-  typedef concepts::Digraph Digraph;
-  typedef int Value;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-  typedef concepts::ReadMap<Arc,Value> CapMap;
-  typedef concepts::ReadWriteMap<Node,Value> CardMap;
-  typedef concepts::ReadWriteMap<Node,bool> ProcMap;
-  typedef Digraph::NodeMap<int> HeapCrossRef;
-
-  Digraph g;
-  Node n,s;
-  CapMap cap;
-  CardMap card;
-  ProcMap proc;
-  HeapCrossRef crossref(g);
-
-  typedef MaxCardinalitySearch<Digraph,CapMap>
-    ::SetCapacityMap<CapMap>
-    ::SetCardinalityMap<CardMap>
-    ::SetProcessedMap<ProcMap>
-    ::SetStandardHeap<BinHeap<Value,HeapCrossRef> >
-    ::Create MaxCardType;
-
-  MaxCardType maxcard(g,cap);
-  const MaxCardType& const_maxcard = maxcard;
-
-  const MaxCardType::Heap& heap_const = const_maxcard.heap();
-  MaxCardType::Heap& heap = const_cast<MaxCardType::Heap&>(heap_const);
-  maxcard.heap(heap,crossref);
-
-  maxcard.capacityMap(cap).cardinalityMap(card).processedMap(proc);
-
-  maxcard.init();
-  maxcard.addSource(s);
-  n = maxcard.nextNode();
-   maxcard.processNextNode();
-   maxcard.start();
-   maxcard.run(s);
-   maxcard.run();
- }
-
- void checkWithIntMap( std::istringstream& input)
- {
-   typedef SmartDigraph Digraph;
-   typedef Digraph::Node Node;
-   typedef Digraph::ArcMap<int> CapMap;
-
-   Digraph g;
-   Node s,x,y,z,a;
-   CapMap cap(g);
-
-   DigraphReader<Digraph>(g,input).
-     arcMap("capacity", cap).
-     node("s",s).
-     node("x",x).
-     node("y",y).
-     node("z",z).
-     run();
-
-   MaxCardinalitySearch<Digraph,CapMap> maxcard(g,cap);
-
-   maxcard.init();
-   maxcard.addSource(s);
-   maxcard.start(x);
-
-   check(maxcard.processed(s) && !maxcard.processed(x) &&
-         !maxcard.processed(y), "Wrong processed()!");
-
-   a=maxcard.nextNode();
-   check(maxcard.processNextNode()==a,
-         "Wrong nextNode() or processNextNode() return value!");
-
-   check(maxcard.processed(a), "Wrong processNextNode()!");
-
-   maxcard.start();
-   check(maxcard.cardinality(x)==2 && maxcard.cardinality(y)>=4,
-         "Wrong cardinalities!");
- }
-
- void checkWithConst1Map(std::istringstream &input) {
-   typedef SmartDigraph Digraph;
-   typedef Digraph::Node Node;
-
-   Digraph g;
-   Node s,x,y,z;
-
-  DigraphReader<Digraph>(g,input).
-    node("s",s).
-    node("x",x).
-    node("y",y).
-    node("z",z).
-    run();
-
-  MaxCardinalitySearch<Digraph> maxcard(g);
-  maxcard.run(s);
-  check(maxcard.cardinality(x)==1 &&
-        maxcard.cardinality(y)+maxcard.cardinality(z)==3,
-        "Wrong cardinalities!");
-}
-
-int main() {
-
-  std::istringstream input1(test_lgf);
-  checkWithIntMap(input1);
-
-  std::istringstream input2(test_lgf);
-  checkWithConst1Map(input2);
-}
Index: test/max_clique_test.cc
===================================================================
--- test/max_clique_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,188 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * 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 <sstream>
-#include <lemon/list_graph.h>
-#include <lemon/full_graph.h>
-#include <lemon/grid_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/grosso_locatelli_pullan_mc.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label max_clique\n"
-  "1     0\n"
-  "2     0\n"
-  "3     0\n"
-  "4     1\n"
-  "5     1\n"
-  "6     1\n"
-  "7     1\n"
-  "@edges\n"
-  "    label\n"
-  "1 2     1\n"
-  "1 3     2\n"
-  "1 4     3\n"
-  "1 6     4\n"
-  "2 3     5\n"
-  "2 5     6\n"
-  "2 7     7\n"
-  "3 4     8\n"
-  "3 5     9\n"
-  "4 5    10\n"
-  "4 6    11\n"
-  "4 7    12\n"
-  "5 6    13\n"
-  "5 7    14\n"
-  "6 7    15\n";
-
-
-// Check with general graphs
-template <typename Param>
-void checkMaxCliqueGeneral(Param rule) {
-  typedef ListGraph GR;
-  typedef GrossoLocatelliPullanMc<GR> McAlg;
-  typedef McAlg::CliqueNodeIt CliqueIt;
-
-  // Basic tests
-  {
-    GR g;
-    GR::NodeMap<bool> map(g);
-    McAlg mc(g);
-    mc.iterationLimit(50);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 0, "Wrong clique size");
-    check(CliqueIt(mc) == INVALID, "Wrong CliqueNodeIt");
-
-    GR::Node u = g.addNode();
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 1, "Wrong clique size");
-    mc.cliqueMap(map);
-    check(map[u], "Wrong clique map");
-    CliqueIt it1(mc);
-    check(static_cast<GR::Node>(it1) == u && ++it1 == INVALID,
-          "Wrong CliqueNodeIt");
-
-    GR::Node v = g.addNode();
-    check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 1, "Wrong clique size");
-    mc.cliqueMap(map);
-    check((map[u] && !map[v]) || (map[v] && !map[u]), "Wrong clique map");
-    CliqueIt it2(mc);
-    check(it2 != INVALID && ++it2 == INVALID, "Wrong CliqueNodeIt");
-
-    g.addEdge(u, v);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 2, "Wrong clique size");
-    mc.cliqueMap(map);
-    check(map[u] && map[v], "Wrong clique map");
-    CliqueIt it3(mc);
-    check(it3 != INVALID && ++it3 != INVALID && ++it3 == INVALID,
-          "Wrong CliqueNodeIt");
-  }
-
-  // Test graph
-  {
-    GR g;
-    GR::NodeMap<bool> max_clique(g);
-    GR::NodeMap<bool> map(g);
-    std::istringstream input(test_lgf);
-    graphReader(g, input)
-      .nodeMap("max_clique", max_clique)
-      .run();
-
-    McAlg mc(g);
-    mc.iterationLimit(50);
-    check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 4, "Wrong clique size");
-    mc.cliqueMap(map);
-    for (GR::NodeIt n(g); n != INVALID; ++n) {
-      check(map[n] == max_clique[n], "Wrong clique map");
-    }
-    int cnt = 0;
-    for (CliqueIt n(mc); n != INVALID; ++n) {
-      cnt++;
-      check(map[n] && max_clique[n], "Wrong CliqueNodeIt");
-    }
-    check(cnt == 4, "Wrong CliqueNodeIt");
-  }
-}
-
-// Check with full graphs
-template <typename Param>
-void checkMaxCliqueFullGraph(Param rule) {
-  typedef FullGraph GR;
-  typedef GrossoLocatelliPullanMc<FullGraph> McAlg;
-  typedef McAlg::CliqueNodeIt CliqueIt;
-
-  for (int size = 0; size <= 40; size = size * 3 + 1) {
-    GR g(size);
-    GR::NodeMap<bool> map(g);
-    McAlg mc(g);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == size, "Wrong clique size");
-    mc.cliqueMap(map);
-    for (GR::NodeIt n(g); n != INVALID; ++n) {
-      check(map[n], "Wrong clique map");
-    }
-    int cnt = 0;
-    for (CliqueIt n(mc); n != INVALID; ++n) cnt++;
-    check(cnt == size, "Wrong CliqueNodeIt");
-  }
-}
-
-// Check with grid graphs
-template <typename Param>
-void checkMaxCliqueGridGraph(Param rule) {
-  GridGraph g(5, 7);
-  GridGraph::NodeMap<char> map(g);
-  GrossoLocatelliPullanMc<GridGraph> mc(g);
-
-  mc.iterationLimit(100);
-  check(mc.run(rule) == mc.ITERATION_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-
-  mc.stepLimit(100);
-  check(mc.run(rule) == mc.STEP_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-
-  mc.sizeLimit(2);
-  check(mc.run(rule) == mc.SIZE_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-}
-
-
-int main() {
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::RANDOM);
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::DEGREE_BASED);
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::PENALTY_BASED);
-
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::RANDOM);
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::DEGREE_BASED);
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::PENALTY_BASED);
-
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::RANDOM);
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::DEGREE_BASED);
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::PENALTY_BASED);
-
-  return 0;
-}
Index: test/max_flow_test.cc
===================================================================
--- test/max_flow_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,395 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * 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 "test_tools.h"
-#include <lemon/smart_graph.h>
-#include <lemon/preflow.h>
-#include <lemon/edmonds_karp.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/elevator.h>
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "8\n"
-  "9\n"
-  "@arcs\n"
-  "    label capacity\n"
-  "0 1 0     20\n"
-  "0 2 1     0\n"
-  "1 1 2     3\n"
-  "1 2 3     8\n"
-  "1 3 4     8\n"
-  "2 5 5     5\n"
-  "3 2 6     5\n"
-  "3 5 7     5\n"
-  "3 6 8     5\n"
-  "4 3 9     3\n"
-  "5 7 10    3\n"
-  "5 6 11    10\n"
-  "5 8 12    10\n"
-  "6 8 13    8\n"
-  "8 9 14    20\n"
-  "8 1 15    5\n"
-  "9 5 16    5\n"
-  "@attributes\n"
-  "source 1\n"
-  "target 8\n";
-
-
-// Checks the general interface of a max flow algorithm
-template <typename GR, typename CAP>
-struct MaxFlowClassConcept
-{
-
-  template <typename MF>
-  struct Constraints {
-
-    typedef typename GR::Node Node;
-    typedef typename GR::Arc Arc;
-    typedef typename CAP::Value Value;
-    typedef concepts::ReadWriteMap<Arc, Value> FlowMap;
-    typedef concepts::WriteMap<Node, bool> CutMap;
-
-    GR g;
-    Node n;
-    Arc e;
-    CAP cap;
-    FlowMap flow;
-    CutMap cut;
-    Value v;
-    bool b;
-
-    void constraints() {
-      checkConcept<concepts::Digraph, GR>();
-
-      const Constraints& me = *this;
-
-      typedef typename MF
-          ::template SetFlowMap<FlowMap>
-          ::Create MaxFlowType;
-      typedef typename MF::Create MaxFlowType2;
-      MaxFlowType max_flow(me.g, me.cap, me.n, me.n);
-      const MaxFlowType& const_max_flow = max_flow;
-
-      max_flow
-          .capacityMap(cap)
-          .flowMap(flow)
-          .source(n)
-          .target(n);
-
-      typename MaxFlowType::Tolerance tol = const_max_flow.tolerance();
-      max_flow.tolerance(tol);
-
-      max_flow.init();
-      max_flow.init(cap);
-      max_flow.run();
-
-      v = const_max_flow.flowValue();
-      v = const_max_flow.flow(e);
-      const FlowMap& fm = const_max_flow.flowMap();
-
-      b = const_max_flow.minCut(n);
-      const_max_flow.minCutMap(cut);
-
-      ::lemon::ignore_unused_variable_warning(fm);
-    }
-
-  };
-
-};
-
-// Checks the specific parts of Preflow's interface
-void checkPreflowCompile()
-{
-  typedef int Value;
-  typedef concepts::Digraph Digraph;
-  typedef concepts::ReadMap<Digraph::Arc, Value> CapMap;
-  typedef Elevator<Digraph, Digraph::Node> Elev;
-  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
-
-  Digraph g;
-  Digraph::Node n;
-  CapMap cap;
-
-  typedef Preflow<Digraph, CapMap>
-      ::SetElevator<Elev>
-      ::SetStandardElevator<LinkedElev>
-      ::Create PreflowType;
-  PreflowType preflow_test(g, cap, n, n);
-  const PreflowType& const_preflow_test = preflow_test;
-
-  const PreflowType::Elevator& elev = const_preflow_test.elevator();
-  preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
-
-  bool b = preflow_test.init(cap);
-  preflow_test.startFirstPhase();
-  preflow_test.startSecondPhase();
-  preflow_test.runMinCut();
-
-  ::lemon::ignore_unused_variable_warning(b);
-}
-
-// Checks the specific parts of EdmondsKarp's interface
-void checkEdmondsKarpCompile()
-{
-  typedef int Value;
-  typedef concepts::Digraph Digraph;
-  typedef concepts::ReadMap<Digraph::Arc, Value> CapMap;
-  typedef Elevator<Digraph, Digraph::Node> Elev;
-  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
-
-  Digraph g;
-  Digraph::Node n;
-  CapMap cap;
-
-  EdmondsKarp<Digraph, CapMap> ek_test(g, cap, n, n);
-
-  ek_test.init(cap);
-  bool b = ek_test.checkedInit(cap);
-  b = ek_test.augment();
-  ek_test.start();
-
-  ::lemon::ignore_unused_variable_warning(b);
-}
-
-
-template <typename T>
-T cutValue (const SmartDigraph& g,
-              const SmartDigraph::NodeMap<bool>& cut,
-              const SmartDigraph::ArcMap<T>& cap) {
-
-  T c=0;
-  for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
-    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
-  }
-  return c;
-}
-
-template <typename T>
-bool checkFlow(const SmartDigraph& g,
-               const SmartDigraph::ArcMap<T>& flow,
-               const SmartDigraph::ArcMap<T>& cap,
-               SmartDigraph::Node s, SmartDigraph::Node t) {
-
-  for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
-    if (flow[e] < 0 || flow[e] > cap[e]) return false;
-  }
-
-  for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
-    if (n == s || n == t) continue;
-    T sum = 0;
-    for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
-      sum += flow[e];
-    }
-    for (SmartDigraph::InArcIt e(g, n); e != INVALID; ++e) {
-      sum -= flow[e];
-    }
-    if (sum != 0) return false;
-  }
-  return true;
-}
-
-void initFlowTest()
-{
-  DIGRAPH_TYPEDEFS(SmartDigraph);
-
-  SmartDigraph g;
-  SmartDigraph::ArcMap<int> cap(g),iflow(g);
-  Node s=g.addNode(); Node t=g.addNode();
-  Node n1=g.addNode(); Node n2=g.addNode();
-  Arc a;
-  a=g.addArc(s,n1); cap[a]=20; iflow[a]=20;
-  a=g.addArc(n1,n2); cap[a]=10; iflow[a]=0;
-  a=g.addArc(n2,t); cap[a]=20; iflow[a]=0;
-
-  Preflow<SmartDigraph> pre(g,cap,s,t);
-  pre.init(iflow);
-  pre.startFirstPhase();
-  check(pre.flowValue() == 10, "The incorrect max flow value.");
-  check(pre.minCut(s), "Wrong min cut (Node s).");
-  check(pre.minCut(n1), "Wrong min cut (Node n1).");
-  check(!pre.minCut(n2), "Wrong min cut (Node n2).");
-  check(!pre.minCut(t), "Wrong min cut (Node t).");
-}
-
-template <typename MF, typename SF>
-void checkMaxFlowAlg() {
-  typedef SmartDigraph Digraph;
-  DIGRAPH_TYPEDEFS(Digraph);
-
-  typedef typename MF::Value Value;
-  typedef Digraph::ArcMap<Value> CapMap;
-  typedef CapMap FlowMap;
-  typedef BoolNodeMap CutMap;
-
-  Digraph g;
-  Node s, t;
-  CapMap cap(g);
-  std::istringstream input(test_lgf);
-  DigraphReader<Digraph>(g,input)
-      .arcMap("capacity", cap)
-      .node("source",s)
-      .node("target",t)
-      .run();
-
-  MF max_flow(g, cap, s, t);
-  max_flow.run();
-
-  check(checkFlow(g, max_flow.flowMap(), cap, s, t),
-        "The flow is not feasible.");
-
-  CutMap min_cut(g);
-  max_flow.minCutMap(min_cut);
-  Value min_cut_value = cutValue(g, min_cut, cap);
-
-  check(max_flow.flowValue() == min_cut_value,
-        "The max flow value is not equal to the min cut value.");
-
-  FlowMap flow(g);
-  for (ArcIt e(g); e != INVALID; ++e) flow[e] = max_flow.flowMap()[e];
-
-  Value flow_value = max_flow.flowValue();
-
-  for (ArcIt e(g); e != INVALID; ++e) cap[e] = 2 * cap[e];
-  max_flow.init(flow);
-
-  SF::startFirstPhase(max_flow);       // start first phase of the algorithm
-
-  CutMap min_cut1(g);
-  max_flow.minCutMap(min_cut1);
-  min_cut_value = cutValue(g, min_cut1, cap);
-
-  check(max_flow.flowValue() == min_cut_value &&
-        min_cut_value == 2 * flow_value,
-        "The max flow value or the min cut value is wrong.");
-
-  SF::startSecondPhase(max_flow);       // start second phase of the algorithm
-
-  check(checkFlow(g, max_flow.flowMap(), cap, s, t),
-        "The flow is not feasible.");
-
-  CutMap min_cut2(g);
-  max_flow.minCutMap(min_cut2);
-  min_cut_value = cutValue(g, min_cut2, cap);
-
-  check(max_flow.flowValue() == min_cut_value &&
-        min_cut_value == 2 * flow_value,
-        "The max flow value or the min cut value was not doubled");
-
-
-  max_flow.flowMap(flow);
-
-  NodeIt tmp1(g, s);
-  ++tmp1;
-  if (tmp1 != INVALID) s = tmp1;
-
-  NodeIt tmp2(g, t);
-  ++tmp2;
-  if (tmp2 != INVALID) t = tmp2;
-
-  max_flow.source(s);
-  max_flow.target(t);
-
-  max_flow.run();
-
-  CutMap min_cut3(g);
-  max_flow.minCutMap(min_cut3);
-  min_cut_value=cutValue(g, min_cut3, cap);
-
-  check(max_flow.flowValue() == min_cut_value,
-        "The max flow value or the min cut value is wrong.");
-}
-
-// Struct for calling start functions of a general max flow algorithm
-template <typename MF>
-struct GeneralStartFunctions {
-
-  static void startFirstPhase(MF& mf) {
-    mf.start();
-  }
-
-  static void startSecondPhase(MF& mf) {
-    ::lemon::ignore_unused_variable_warning(mf);
-  }
-
-};
-
-// Struct for calling start functions of Preflow
-template <typename MF>
-struct PreflowStartFunctions {
-
-  static void startFirstPhase(MF& mf) {
-    mf.startFirstPhase();
-  }
-
-  static void startSecondPhase(MF& mf) {
-    mf.startSecondPhase();
-  }
-
-};
-
-int main() {
-
-  typedef concepts::Digraph GR;
-  typedef concepts::ReadMap<GR::Arc, int> CM1;
-  typedef concepts::ReadMap<GR::Arc, double> CM2;
-
-  // Check the interface of Preflow
-  checkConcept< MaxFlowClassConcept<GR, CM1>,
-                Preflow<GR, CM1> >();
-  checkConcept< MaxFlowClassConcept<GR, CM2>,
-                Preflow<GR, CM2> >();
-
-  // Check the interface of EdmondsKarp
-  checkConcept< MaxFlowClassConcept<GR, CM1>,
-                EdmondsKarp<GR, CM1> >();
-  checkConcept< MaxFlowClassConcept<GR, CM2>,
-                EdmondsKarp<GR, CM2> >();
-
-  // Check Preflow
-  typedef Preflow<SmartDigraph, SmartDigraph::ArcMap<int> > PType1;
-  typedef Preflow<SmartDigraph, SmartDigraph::ArcMap<float> > PType2;
-  checkMaxFlowAlg<PType1, PreflowStartFunctions<PType1> >();
-  checkMaxFlowAlg<PType2, PreflowStartFunctions<PType2> >();
-  initFlowTest();
-
-  // Check EdmondsKarp
-  typedef EdmondsKarp<SmartDigraph, SmartDigraph::ArcMap<int> > EKType1;
-  typedef EdmondsKarp<SmartDigraph, SmartDigraph::ArcMap<float> > EKType2;
-  checkMaxFlowAlg<EKType1, GeneralStartFunctions<EKType1> >();
-  checkMaxFlowAlg<EKType2, GeneralStartFunctions<EKType2> >();
-
-  initFlowTest();
-
-  return 0;
-}
Index: test/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 1270)
+++ test/min_cost_arborescence_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 1318)
+++ test/min_cost_flow_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -396,10 +396,4 @@
   checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
            mcf3.OPTIMAL, true,     -300, test_str + "-18", GEQ);
-
-  // Tests for empty graph
-  Digraph gr0;
-  MCF mcf0(gr0);
-  mcf0.run(param);
-  check(mcf0.totalCost() == 0, "Wrong total cost");  
 }
 
Index: test/min_mean_cycle_test.cc
===================================================================
--- test/min_mean_cycle_test.cc	(revision 1270)
+++ test/min_mean_cycle_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -111,5 +111,5 @@
                  int cost, int size) {
   MMC alg(gr, lm);
-  check(alg.findCycleMean(), "Wrong result");
+  alg.findCycleMean();
   check(alg.cycleMean() == static_cast<double>(cost) / size,
         "Wrong cycle mean");
@@ -211,11 +211,4 @@
     checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
     checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-
-    // Howard with iteration limit
-    HowardMmc<GR, IntArcMap> mmc(gr, l1);
-    check((mmc.findCycleMean(2) == HowardMmc<GR, IntArcMap>::ITERATION_LIMIT),
-      "Wrong termination cause");
-    check((mmc.findCycleMean(4) == HowardMmc<GR, IntArcMap>::OPTIMAL),
-      "Wrong termination cause");
   }
 
Index: test/mip_test.cc
===================================================================
--- test/mip_test.cc	(revision 1300)
+++ test/mip_test.cc	(revision 795)
@@ -31,8 +31,4 @@
 #ifdef LEMON_HAVE_CBC
 #include <lemon/cbc.h>
-#endif
-
-#ifdef LEMON_HAVE_MIP
-#include <lemon/lp.h>
 #endif
 
@@ -133,12 +129,4 @@
 {
 
-#ifdef LEMON_HAVE_MIP
-  {
-    Mip mip1;
-    aTest(mip1);
-    cloneTest<Mip>();
-  }
-#endif
-
 #ifdef LEMON_HAVE_GLPK
   {
Index: test/nagamochi_ibaraki_test.cc
===================================================================
--- test/nagamochi_ibaraki_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,142 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * 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 <sstream>
-
-#include <lemon/smart_graph.h>
-#include <lemon/adaptors.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/nagamochi_ibaraki.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-using namespace std;
-
-const std::string lgf =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "@edges\n"
-  "     cap1 cap2 cap3\n"
-  "0 1  1    1    1   \n"
-  "0 2  2    2    4   \n"
-  "1 2  4    4    4   \n"
-  "3 4  1    1    1   \n"
-  "3 5  2    2    4   \n"
-  "4 5  4    4    4   \n"
-  "2 3  1    6    6   \n";
-
-void checkNagamochiIbarakiCompile()
-{
-  typedef int Value;
-  typedef concepts::Graph Graph;
-
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef concepts::ReadMap<Edge, Value> CapMap;
-  typedef concepts::WriteMap<Node, bool> CutMap;
-
-  Graph g;
-  Node n;
-  CapMap cap;
-  CutMap cut;
-  Value v;
-  bool b;
-  ::lemon::ignore_unused_variable_warning(v,b);
-
-  NagamochiIbaraki<Graph, CapMap> ni_test(g, cap);
-  const NagamochiIbaraki<Graph, CapMap>& const_ni_test = ni_test;
-
-  ni_test.init();
-  ni_test.start();
-  b = ni_test.processNextPhase();
-  ni_test.run();
-
-  v = const_ni_test.minCutValue();
-  v = const_ni_test.minCutMap(cut);
-}
-
-template <typename Graph, typename CapMap, typename CutMap>
-typename CapMap::Value
-  cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
-{
-  typename CapMap::Value sum = 0;
-  for (typename Graph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (cut[graph.u(e)] != cut[graph.v(e)]) {
-      sum += cap[e];
-    }
-  }
-  return sum;
-}
-
-int main() {
-  SmartGraph graph;
-  SmartGraph::EdgeMap<int> cap1(graph), cap2(graph), cap3(graph);
-  SmartGraph::NodeMap<bool> cut(graph);
-
-  istringstream input(lgf);
-  graphReader(graph, input)
-    .edgeMap("cap1", cap1)
-    .edgeMap("cap2", cap2)
-    .edgeMap("cap3", cap3)
-    .run();
-
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap1);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 1, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap2);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 3, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap2, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap3);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 5, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph>::SetUnitCapacity::Create ni(graph);
-    ni.run();
-    ni.minCutMap(cut);
-
-    ConstMap<SmartGraph::Edge, int> cap4(1);
-    check(ni.minCutValue() == 1, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap4, cut), "Wrong cut value");
-  }
-
-  return 0;
-}
Index: test/path_test.cc
===================================================================
--- test/path_test.cc	(revision 1270)
+++ test/path_test.cc	(revision 1144)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -22,5 +22,4 @@
 #include <lemon/concepts/path.h>
 #include <lemon/concepts/digraph.h>
-#include <lemon/concept_check.h>
 
 #include <lemon/path.h>
@@ -32,307 +31,42 @@
 using namespace lemon;
 
-template <typename GR>
-void checkConcepts() {
-  checkConcept<concepts::Path<GR>, concepts::Path<GR> >();
-  checkConcept<concepts::Path<GR>, Path<GR> >();
-  checkConcept<concepts::Path<GR>, SimplePath<GR> >();
-  checkConcept<concepts::Path<GR>, StaticPath<GR> >();
-  checkConcept<concepts::Path<GR>, ListPath<GR> >();
-}
-
-// Conecpt checking for path structures
-void checkPathConcepts() {
-  checkConcepts<concepts::Digraph>();
-  checkConcepts<ListDigraph>();
+void check_concepts() {
+  checkConcept<concepts::Path<ListDigraph>, concepts::Path<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, Path<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, SimplePath<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, StaticPath<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, ListPath<ListDigraph> >();
 }
 
 // Check if proper copy consructor is called (use valgrind for testing)
-template <typename GR, typename P1, typename P2>
-void checkCopy(typename GR::Arc a) {
-  P1 p;
+template<class _Path>
+void checkCopy()
+{
+  ListDigraph g;
+  ListDigraph::Arc a  = g.addArc(g.addNode(), g.addNode());
+  
+  _Path p,q;
   p.addBack(a);
-  P1 q;
-  q = p;
-  P1 r(p);
-  P2 q2;
-  q2 = p;
-  P2 r2(p);
+  q=p;
+  _Path r(p);
+  StaticPath<ListDigraph> s(r);
 }
+  
+int main() {
+  check_concepts();
 
-// Tests for copy constructors and assignment operators of paths
-void checkPathCopy() {
+  checkCopy<Path<ListDigraph> >();
+  checkCopy<SimplePath<ListDigraph> >();
+  checkCopy<ListPath<ListDigraph> >();
+
   ListDigraph g;
-  ListDigraph::Arc a = g.addArc(g.addNode(), g.addNode());
-
-  typedef Path<ListDigraph> Path1;
-  typedef SimplePath<ListDigraph> Path2;
-  typedef ListPath<ListDigraph> Path3;
-  typedef StaticPath<ListDigraph> Path4;
-  checkCopy<ListDigraph, Path1, Path2>(a);
-  checkCopy<ListDigraph, Path1, Path3>(a);
-  checkCopy<ListDigraph, Path1, Path4>(a);
-  checkCopy<ListDigraph, Path2, Path1>(a);
-  checkCopy<ListDigraph, Path2, Path3>(a);
-  checkCopy<ListDigraph, Path2, Path4>(a);
-  checkCopy<ListDigraph, Path3, Path1>(a);
-  checkCopy<ListDigraph, Path3, Path2>(a);
-  checkCopy<ListDigraph, Path3, Path4>(a);
-}
-
-// Class for testing path functions
-class CheckPathFunctions {
-  typedef ListDigraph GR;
-  DIGRAPH_TYPEDEFS(GR);
-  GR gr;
-  const GR& cgr;
-  Node n1, n2, n3, n4;
-  Node tmp_n;
-  Arc a1, a2, a3, a4;
-  Arc tmp_a;
-
-public:
-
-  CheckPathFunctions() : cgr(gr) {
-    n1 = gr.addNode();
-    n2 = gr.addNode();
-    n3 = gr.addNode();
-    n4 = gr.addNode();
-    a1 = gr.addArc(n1, n2);
-    a2 = gr.addArc(n2, n3);
-    a3 = gr.addArc(n3, n4);
-    a4 = gr.addArc(n4, n1);
-  }
-
-  void run() {
-    checkBackAndFrontInsertablePath<Path<GR> >();
-    checkBackAndFrontInsertablePath<ListPath<GR> >();
-    checkBackInsertablePath<SimplePath<GR> >();
-
-    checkListPathSplitAndSplice();
-  }
-
-private:
-
-  template <typename P>
-  void checkBackInsertablePath() {
-
-    // Create and check empty path
-    P p;
-    const P& cp = p;
-    check(cp.empty(), "The path is not empty");
-    check(cp.length() == 0, "The path is not empty");
-//    check(cp.front() == INVALID, "Wrong front()");
-//    check(cp.back() == INVALID, "Wrong back()");
-    typename P::ArcIt ai(cp);
-    check(ai == INVALID, "Wrong ArcIt");
-    check(pathSource(cgr, cp) == INVALID, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == INVALID, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-    PathNodeIt<P> ni(cgr, cp);
-    check(ni == INVALID, "Wrong PathNodeIt");
-
-    // Check single-arc path
-    p.addBack(a1);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 1, "Wrong length");
-    check(cp.front() == a1, "Wrong front()");
-    check(cp.back() == a1, "Wrong back()");
-    check(cp.nth(0) == a1, "Wrong nth()");
-    ai = cp.nthIt(0);
-    check((tmp_a = ai) == a1, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    typename P::ArcIt ai2(cp);
-    check((tmp_a = ai2) == a1, "Wrong ArcIt");
-    check(++ai2 == INVALID, "Wrong ArcIt");
-    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-    PathNodeIt<P> ni2(cgr, cp);
-    check((tmp_n = ni2) == n1, "Wrong PathNodeIt");
-    check((tmp_n = ++ni2) == n2, "Wrong PathNodeIt");
-    check(++ni2 == INVALID, "Wrong PathNodeIt");
-
-    // Check adding more arcs
-    p.addBack(a2);
-    p.addBack(a3);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 3, "Wrong length");
-    check(cp.front() == a1, "Wrong front()");
-    check(cp.back() == a3, "Wrong back()");
-    check(cp.nth(0) == a1, "Wrong nth()");
-    check(cp.nth(1) == a2, "Wrong nth()");
-    check(cp.nth(2) == a3, "Wrong nth()");
-    typename P::ArcIt ai3(cp);
-    check((tmp_a = ai3) == a1, "Wrong ArcIt");
-    check((tmp_a = ++ai3) == a2, "Wrong nthIt()");
-    check((tmp_a = ++ai3) == a3, "Wrong nthIt()");
-    check(++ai3 == INVALID, "Wrong nthIt()");
-    ai = cp.nthIt(0);
-    check((tmp_a = ai) == a1, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
-    ai = cp.nthIt(2);
-    check((tmp_a = ai) == a3, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n4, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-    PathNodeIt<P> ni3(cgr, cp);
-    check((tmp_n = ni3) == n1, "Wrong PathNodeIt");
-    check((tmp_n = ++ni3) == n2, "Wrong PathNodeIt");
-    check((tmp_n = ++ni3) == n3, "Wrong PathNodeIt");
-    check((tmp_n = ++ni3) == n4, "Wrong PathNodeIt");
-    check(++ni3 == INVALID, "Wrong PathNodeIt");
-
-    // Check arc removal and addition
-    p.eraseBack();
-    p.eraseBack();
-    p.addBack(a2);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 2, "Wrong length");
-    check(cp.front() == a1, "Wrong front()");
-    check(cp.back() == a2, "Wrong back()");
-    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n3, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-
-    // Check clear()
-    p.clear();
-    check(cp.empty(), "The path is not empty");
-    check(cp.length() == 0, "The path is not empty");
-
-    // Check inconsistent path
-    p.addBack(a4);
-    p.addBack(a2);
-    p.addBack(a1);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 3, "Wrong length");
-    check(cp.front() == a4, "Wrong front()");
-    check(cp.back() == a1, "Wrong back()");
-    check(pathSource(cgr, cp) == n4, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
-    check(!checkPath(cgr, cp), "Wrong checkPath()");
-  }
-
-  template <typename P>
-  void checkBackAndFrontInsertablePath() {
-
-    // Include back insertable test cases
-    checkBackInsertablePath<P>();
-
-    // Check front and back insertion
-    P p;
-    const P& cp = p;
-    p.addFront(a4);
-    p.addBack(a1);
-    p.addFront(a3);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 3, "Wrong length");
-    check(cp.front() == a3, "Wrong front()");
-    check(cp.back() == a1, "Wrong back()");
-    check(cp.nth(0) == a3, "Wrong nth()");
-    check(cp.nth(1) == a4, "Wrong nth()");
-    check(cp.nth(2) == a1, "Wrong nth()");
-    typename P::ArcIt ai(cp);
-    check((tmp_a = ai) == a3, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a1, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    ai = cp.nthIt(0);
-    check((tmp_a = ai) == a3, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    ai = cp.nthIt(2);
-    check((tmp_a = ai) == a1, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(pathSource(cgr, cp) == n3, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-
-    // Check eraseFront()
-    p.eraseFront();
-    p.addBack(a2);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 3, "Wrong length");
-    check(cp.front() == a4, "Wrong front()");
-    check(cp.back() == a2, "Wrong back()");
-    check(cp.nth(0) == a4, "Wrong nth()");
-    check(cp.nth(1) == a1, "Wrong nth()");
-    check(cp.nth(2) == a2, "Wrong nth()");
-    typename P::ArcIt ai2(cp);
-    check((tmp_a = ai2) == a4, "Wrong ArcIt");
-    check((tmp_a = ++ai2) == a1, "Wrong nthIt()");
-    check((tmp_a = ++ai2) == a2, "Wrong nthIt()");
-    check(++ai2 == INVALID, "Wrong nthIt()");
-    ai = cp.nthIt(0);
-    check((tmp_a = ai) == a4, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a1, "Wrong nthIt()");
-    ai = cp.nthIt(2);
-    check((tmp_a = ai) == a2, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(pathSource(cgr, cp) == n4, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n3, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-  }
-
-  void checkListPathSplitAndSplice() {
-
-    // Build a path with spliceFront() and spliceBack()
-    ListPath<GR> p1, p2, p3, p4;
-    p1.addBack(a3);
-    p1.addFront(a2);
-    p2.addBack(a1);
-    p1.spliceFront(p2);
-    p3.addFront(a4);
-    p1.spliceBack(p3);
-    check(p1.length() == 4, "Wrong length");
-    check(p1.front() == a1, "Wrong front()");
-    check(p1.back() == a4, "Wrong back()");
-    ListPath<GR>::ArcIt ai(p1);
-    check((tmp_a = ai) == a1, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a3, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(checkPath(cgr, p1), "Wrong checkPath()");
-
-    // Check split()
-    p1.split(p1.nthIt(2), p2);
-    check(p1.length() == 2, "Wrong length");
-    ai = p1.nthIt(0);
-    check((tmp_a = ai) == a1, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(checkPath(cgr, p1), "Wrong checkPath()");
-    check(p2.length() == 2, "Wrong length");
-    ai = p2.nthIt(0);
-    check((tmp_a = ai) == a3, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(checkPath(cgr, p2), "Wrong checkPath()");
-
-    // Check split() and splice()
-    p1.spliceFront(p2);
-    p1.split(p1.nthIt(2), p2);
-    p2.split(p2.nthIt(1), p3);
-    p2.spliceBack(p1);
-    p2.splice(p2.nthIt(1), p3);
-    check(p2.length() == 4, "Wrong length");
-    check(p2.front() == a1, "Wrong front()");
-    check(p2.back() == a4, "Wrong back()");
-    ai = p2.nthIt(0);
-    check((tmp_a = ai) == a1, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a3, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(checkPath(cgr, p2), "Wrong checkPath()");
-  }
-
-};
-
-int main() {
-  checkPathConcepts();
-  checkPathCopy();
-  CheckPathFunctions cpf;
-  cpf.run();
+  ListDigraph::Arc a  = g.addArc(g.addNode(), g.addNode());
+  
+  Path<ListDigraph> p;
+  StaticPath<ListDigraph> q,r;
+  p.addBack(a);
+  q=p;
+  r=q;
+  StaticPath<ListDigraph> s(q);
 
   return 0;
Index: test/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 1263)
+++ test/preflow_test.cc	(revision 1263)
@@ -0,0 +1,277 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2011
+ * 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 "test_tools.h"
+#include <lemon/smart_graph.h>
+#include <lemon/preflow.h>
+#include <lemon/concepts/digraph.h>
+#include <lemon/concepts/maps.h>
+#include <lemon/lgf_reader.h>
+#include <lemon/elevator.h>
+
+using namespace lemon;
+
+char test_lgf[] =
+  "@nodes\n"
+  "label\n"
+  "0\n"
+  "1\n"
+  "2\n"
+  "3\n"
+  "4\n"
+  "5\n"
+  "6\n"
+  "7\n"
+  "8\n"
+  "9\n"
+  "@arcs\n"
+  "    label capacity\n"
+  "0 1 0     20\n"
+  "0 2 1     0\n"
+  "1 1 2     3\n"
+  "1 2 3     8\n"
+  "1 3 4     8\n"
+  "2 5 5     5\n"
+  "3 2 6     5\n"
+  "3 5 7     5\n"
+  "3 6 8     5\n"
+  "4 3 9     3\n"
+  "5 7 10    3\n"
+  "5 6 11    10\n"
+  "5 8 12    10\n"
+  "6 8 13    8\n"
+  "8 9 14    20\n"
+  "8 1 15    5\n"
+  "9 5 16    5\n"
+  "@attributes\n"
+  "source 1\n"
+  "target 8\n";
+
+void checkPreflowCompile()
+{
+  typedef int VType;
+  typedef concepts::Digraph Digraph;
+
+  typedef Digraph::Node Node;
+  typedef Digraph::Arc Arc;
+  typedef concepts::ReadMap<Arc,VType> CapMap;
+  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
+  typedef concepts::WriteMap<Node,bool> CutMap;
+
+  typedef Elevator<Digraph, Digraph::Node> Elev;
+  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
+
+  Digraph g;
+  Node n;
+  Arc e;
+  CapMap cap;
+  FlowMap flow;
+  CutMap cut;
+  VType v;
+  bool b;
+  ::lemon::ignore_unused_variable_warning(v,b);
+
+  typedef Preflow<Digraph, CapMap>
+            ::SetFlowMap<FlowMap>
+            ::SetElevator<Elev>
+            ::SetStandardElevator<LinkedElev>
+            ::Create PreflowType;
+  PreflowType preflow_test(g, cap, n, n);
+  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)
+    .flowMap(flow)
+    .source(n)
+    .target(n);
+
+  preflow_test.init();
+  preflow_test.init(cap);
+  preflow_test.startFirstPhase();
+  preflow_test.startSecondPhase();
+  preflow_test.run();
+  preflow_test.runMinCut();
+
+  v = const_preflow_test.flowValue();
+  v = const_preflow_test.flow(e);
+  const FlowMap& fm = const_preflow_test.flowMap();
+  b = const_preflow_test.minCut(n);
+  const_preflow_test.minCutMap(cut);
+
+  ::lemon::ignore_unused_variable_warning(fm);
+}
+
+int cutValue (const SmartDigraph& g,
+              const SmartDigraph::NodeMap<bool>& cut,
+              const SmartDigraph::ArcMap<int>& cap) {
+
+  int c=0;
+  for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
+    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
+  }
+  return c;
+}
+
+bool checkFlow(const SmartDigraph& g,
+               const SmartDigraph::ArcMap<int>& flow,
+               const SmartDigraph::ArcMap<int>& cap,
+               SmartDigraph::Node s, SmartDigraph::Node t) {
+
+  for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
+    if (flow[e] < 0 || flow[e] > cap[e]) return false;
+  }
+
+  for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
+    if (n == s || n == t) continue;
+    int sum = 0;
+    for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
+      sum += flow[e];
+    }
+    for (SmartDigraph::InArcIt e(g, n); e != INVALID; ++e) {
+      sum -= flow[e];
+    }
+    if (sum != 0) return false;
+  }
+  return true;
+}
+
+void initFlowTest()
+{
+  DIGRAPH_TYPEDEFS(SmartDigraph);
+
+  SmartDigraph g;
+  SmartDigraph::ArcMap<int> cap(g),iflow(g);
+  Node s=g.addNode(); Node t=g.addNode();
+  Node n1=g.addNode(); Node n2=g.addNode();
+  Arc a;
+  a=g.addArc(s,n1); cap[a]=20; iflow[a]=20;
+  a=g.addArc(n1,n2); cap[a]=10; iflow[a]=0;
+  a=g.addArc(n2,t); cap[a]=20; iflow[a]=0;
+
+  Preflow<SmartDigraph> pre(g,cap,s,t);
+  pre.init(iflow);
+  pre.startFirstPhase();
+  check(pre.flowValue() == 10, "The incorrect max flow value.");
+  check(pre.minCut(s), "Wrong min cut (Node s).");
+  check(pre.minCut(n1), "Wrong min cut (Node n1).");
+  check(!pre.minCut(n2), "Wrong min cut (Node n2).");
+  check(!pre.minCut(t), "Wrong min cut (Node t).");
+}
+
+
+int main() {
+
+  typedef SmartDigraph Digraph;
+
+  typedef Digraph::Node Node;
+  typedef Digraph::NodeIt NodeIt;
+  typedef Digraph::ArcIt ArcIt;
+  typedef Digraph::ArcMap<int> CapMap;
+  typedef Digraph::ArcMap<int> FlowMap;
+  typedef Digraph::NodeMap<bool> CutMap;
+
+  typedef Preflow<Digraph, CapMap> PType;
+
+  Digraph g;
+  Node s, t;
+  CapMap cap(g);
+  std::istringstream input(test_lgf);
+  DigraphReader<Digraph>(g,input).
+    arcMap("capacity", cap).
+    node("source",s).
+    node("target",t).
+    run();
+
+  PType preflow_test(g, cap, s, t);
+  preflow_test.run();
+
+  check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
+        "The flow is not feasible.");
+
+  CutMap min_cut(g);
+  preflow_test.minCutMap(min_cut);
+  int min_cut_value=cutValue(g,min_cut,cap);
+
+  check(preflow_test.flowValue() == min_cut_value,
+        "The max flow value is not equal to the three min cut values.");
+
+  FlowMap flow(g);
+  for(ArcIt e(g); e!=INVALID; ++e) flow[e] = preflow_test.flowMap()[e];
+
+  int flow_value=preflow_test.flowValue();
+
+  for(ArcIt e(g); e!=INVALID; ++e) cap[e]=2*cap[e];
+  preflow_test.init(flow);
+  preflow_test.startFirstPhase();
+
+  CutMap min_cut1(g);
+  preflow_test.minCutMap(min_cut1);
+  min_cut_value=cutValue(g,min_cut1,cap);
+
+  check(preflow_test.flowValue() == min_cut_value &&
+        min_cut_value == 2*flow_value,
+        "The max flow value or the min cut value is wrong.");
+
+  preflow_test.startSecondPhase();
+
+  check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
+        "The flow is not feasible.");
+
+  CutMap min_cut2(g);
+  preflow_test.minCutMap(min_cut2);
+  min_cut_value=cutValue(g,min_cut2,cap);
+
+  check(preflow_test.flowValue() == min_cut_value &&
+        min_cut_value == 2*flow_value,
+        "The max flow value or the three min cut values were not doubled");
+
+
+  preflow_test.flowMap(flow);
+
+  NodeIt tmp1(g,s);
+  ++tmp1;
+  if ( tmp1 != INVALID ) s=tmp1;
+
+  NodeIt tmp2(g,t);
+  ++tmp2;
+  if ( tmp2 != INVALID ) t=tmp2;
+
+  preflow_test.source(s);
+  preflow_test.target(t);
+
+  preflow_test.run();
+
+  CutMap min_cut3(g);
+  preflow_test.minCutMap(min_cut3);
+  min_cut_value=cutValue(g,min_cut3,cap);
+
+
+  check(preflow_test.flowValue() == min_cut_value,
+        "The max flow value or the three min cut values are incorrect.");
+
+  initFlowTest();
+
+  return 0;
+}
Index: test/radix_sort_test.cc
===================================================================
--- test/radix_sort_test.cc	(revision 1270)
+++ test/radix_sort_test.cc	(revision 467)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -26,5 +26,4 @@
 
 #include <vector>
-#include <list>
 #include <algorithm>
 
@@ -41,56 +40,6 @@
 int negate(int a) { return - a; }
 
-template<class T>
-bool isTheSame(T &a, T&b)
-{
-  typename T::iterator ai=a.begin();
-  typename T::iterator bi=b.begin();
-  for(;ai!=a.end()||bi!=b.end();++ai,++bi)
-    if(*ai!=*bi) return false;
-  return ai==a.end()&&bi==b.end();
-}
 
-template<class T>
-T listsort(typename T::iterator b, typename T::iterator e)
-{
-  if(b==e) return T();
-  typename T::iterator bn=b;
-  if(++bn==e) {
-    T l;
-    l.push_back(*b);
-    return l;
-  }
-  typename T::iterator m=b;
-  bool x=false;
-  for(typename T::iterator i=b;i!=e;++i,x=!x)
-    if(x) ++m;
-  T l1(listsort<T>(b,m));
-  T l2(listsort<T>(m,e));
-  T l;
-  while((!l1.empty())&&(!l2.empty()))
-    if(l1.front()<=l2.front())
-      {
-        l.push_back(l1.front());
-        l1.pop_front();
-      }
-    else {
-      l.push_back(l2.front());
-      l2.pop_front();
-    }
-  while(!l1.empty())
-    {
-      l.push_back(l1.front());
-      l1.pop_front();
-    }
-  while(!l2.empty())
-    {
-      l.push_back(l2.front());
-      l2.pop_front();
-    }
-  return l;
-}
-
-template<class T>
-void generateIntSequence(int n, T & data) {
+void generateIntSequence(int n, std::vector<int>& data) {
   int prime = 9973;
   int root = 136, value = 1;
@@ -101,6 +50,5 @@
 }
 
-template<class T>
-void generateCharSequence(int n, T & data) {
+void generateCharSequence(int n, std::vector<unsigned char>& data) {
   int prime = 251;
   int root = 3, value = root;
@@ -124,13 +72,13 @@
     }
 
-    // radixSort(data2.begin(), data2.end(), Negate());
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
+    radixSort(data2.begin(), data2.end(), Negate());
+    for (int i = 0; i < n; ++i) {
+      check(data1[i] == data2[n - 1 - i], "Test failed");
+    }
 
-    // radixSort(data2.begin(), data2.end(), negate);
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
+    radixSort(data2.begin(), data2.end(), negate);
+    for (int i = 0; i < n; ++i) {
+      check(data1[i] == data2[n - 1 - i], "Test failed");
+    }
 
   }
@@ -147,40 +95,4 @@
       check(data1[i] == data2[i], "Test failed");
     }
-
-  }
-  {
-    std::list<int> data1;
-    generateIntSequence(n, data1);
-
-    std::list<int> data2(listsort<std::list<int> >(data1.begin(), data1.end()));
-
-    radixSort(data1.begin(), data1.end());
-
-    check(isTheSame(data1,data2), "Test failed");
-
-
-    // radixSort(data2.begin(), data2.end(), Negate());
-    // check(isTheSame(data1,data2), "Test failed");
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
-
-    // radixSort(data2.begin(), data2.end(), negate);
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
-
-  }
-
-  {
-    std::list<unsigned char> data1(n);
-    generateCharSequence(n, data1);
-
-    std::list<unsigned char> data2(listsort<std::list<unsigned char> >
-                                   (data1.begin(),
-                                    data1.end()));
-
-    radixSort(data1.begin(), data1.end());
-    check(isTheSame(data1,data2), "Test failed");
 
   }
@@ -225,35 +137,4 @@
 
   }
-  {
-    std::list<int> data1;
-    generateIntSequence(n, data1);
-
-    std::list<int> data2(listsort<std::list<int> >(data1.begin(),
-                                                   data1.end()));
-    stableRadixSort(data1.begin(), data1.end());
-    check(isTheSame(data1,data2), "Test failed");
-
-    // stableRadixSort(data2.begin(), data2.end(), Negate());
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
-
-    // stableRadixSort(data2.begin(), data2.end(), negate);
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
-  }
-
-  {
-    std::list<unsigned char> data1(n);
-    generateCharSequence(n, data1);
-
-    std::list<unsigned char> data2(listsort<std::list<unsigned char> >
-                                   (data1.begin(),
-                                    data1.end()));
-    radixSort(data1.begin(), data1.end());
-    check(isTheSame(data1,data2), "Test failed");
-
-  }
 }
 
Index: test/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 1270)
+++ test/suurballe_test.cc	(revision 1259)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/time_measure_test.cc
===================================================================
--- test/time_measure_test.cc	(revision 1270)
+++ test/time_measure_test.cc	(revision 1257)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/tsp_test.cc
===================================================================
--- test/tsp_test.cc	(revision 1303)
+++ 	(revision )
@@ -1,287 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * 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/full_graph.h>
-#include <lemon/math.h>
-#include <lemon/maps.h>
-#include <lemon/random.h>
-#include <lemon/dim2.h>
-
-#include <lemon/nearest_neighbor_tsp.h>
-#include <lemon/greedy_tsp.h>
-#include <lemon/insertion_tsp.h>
-#include <lemon/christofides_tsp.h>
-#include <lemon/opt2_tsp.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-// // Tests checkMetricCost() function
-// void metricCostTest() {
-//   GRAPH_TYPEDEFS(FullGraph);
-//   FullGraph g(10);
-//   check(checkMetricCost(g, constMap<Edge>(0)), "Wrong checkMetricCost()");
-//   check(checkMetricCost(g, constMap<Edge>(1)), "Wrong checkMetricCost()");
-//   check(!checkMetricCost(g, constMap<Edge>(-1)), "Wrong checkMetricCost()");
-//
-//   FullGraph::EdgeMap<float> cost(g);
-//   for (NodeIt u(g); u != INVALID; ++u) {
-//     for (NodeIt v(g); v != INVALID; ++v) {
-//       if (u == v) continue;
-//       float x1 = g.id(u), x2 = g.id(v);
-//       float y1 = x1 * x1, y2 = x2 * x2;
-//       cost[g.edge(u, v)] = std::sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
-//     }
-//   }
-//   check(checkMetricCost(g, cost), "Wrong checkMetricCost()");
-//   float eps = Tolerance<float>::defaultEpsilon();
-//   cost[g.edge(g(0), g(9))] =
-//     cost[g.edge(g(0), g(8))] + cost[g.edge(g(8), g(9))] + eps * 2;
-//   check(!checkMetricCost(g, cost), "Wrong checkMetricCost()");
-//   check(checkMetricCost(g, cost, Tolerance<float>(eps * 4)),
-//     "Wrong checkMetricCost()");
-// }
-
-// Checks tour validity
-template <typename Container>
-bool checkTour(const FullGraph &gr, const Container &p) {
-  FullGraph::NodeMap<bool> used(gr, false);
-
-  int node_cnt = 0;
-  for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it)
-    {
-      FullGraph::Node node = *it;
-      if (used[node]) return false;
-      used[node] = true;
-      ++node_cnt;
-    }
-
-  return (node_cnt == gr.nodeNum());
-}
-
-// Checks tour validity
-bool checkTourPath(const FullGraph &gr, const Path<FullGraph> &p) {
-  FullGraph::NodeMap<bool> used(gr, false);
-
-  if (!checkPath(gr, p)) return false;
-  if (gr.nodeNum() <= 1 && p.length() != 0) return false;
-  if (gr.nodeNum() > 1 && p.length() != gr.nodeNum()) return false;
-
-  for (int i = 0; i < p.length(); ++i) {
-    if (used[gr.target(p.nth(i))]) return false;
-    used[gr.target(p.nth(i))] = true;
-  }
-  return true;
-}
-
-// Checks tour cost
-template <typename CostMap>
-bool checkCost(const FullGraph &gr, const std::vector<FullGraph::Node> &p,
-               const CostMap &cost, typename CostMap::Value total)
-{
-  typedef typename CostMap::Value Cost;
-
-  Cost s = 0;
-  for (int i = 0; i < int(p.size()) - 1; ++i)
-    s += cost[gr.edge(p[i], p[i+1])];
-  if (int(p.size()) >= 2)
-    s += cost[gr.edge(p.back(), p.front())];
-
-  return !Tolerance<Cost>().different(s, total);
-}
-
-// Checks tour cost
-template <typename CostMap>
-bool checkCost(const FullGraph &, const Path<FullGraph> &p,
-               const CostMap &cost, typename CostMap::Value total)
-{
-  typedef typename CostMap::Value Cost;
-
-  Cost s = 0;
-  for (int i = 0; i < p.length(); ++i)
-    s += cost[p.nth(i)];
-
-  return !Tolerance<Cost>().different(s, total);
-}
-
-// Tests a TSP algorithm on small graphs
-template <typename TSP>
-void tspTestSmall(const std::string &alg_name) {
-  GRAPH_TYPEDEFS(FullGraph);
-
-  for (int n = 0; n <= 5; ++n) {
-    FullGraph g(n);
-    unsigned nsize = n;
-    int esize = n <= 1 ? 0 : n;
-
-    ConstMap<Edge, int> cost_map(1);
-    TSP alg(g, cost_map);
-
-    check(alg.run() == esize, alg_name + ": Wrong total cost");
-    check(alg.tourCost() == esize, alg_name + ": Wrong total cost");
-
-    std::list<Node> list1(nsize), list2;
-    std::vector<Node> vec1(nsize), vec2;
-    alg.tourNodes(list1.begin());
-    alg.tourNodes(vec1.begin());
-    alg.tourNodes(std::front_inserter(list2));
-    alg.tourNodes(std::back_inserter(vec2));
-    check(checkTour(g, alg.tourNodes()), alg_name + ": Wrong node sequence");
-    check(checkTour(g, list1), alg_name + ": Wrong node sequence");
-    check(checkTour(g, vec1), alg_name + ": Wrong node sequence");
-    check(checkTour(g, list2), alg_name + ": Wrong node sequence");
-    check(checkTour(g, vec2), alg_name + ": Wrong node sequence");
-    check(checkCost(g, vec1, constMap<Edge, int>(1), esize),
-      alg_name + ": Wrong tour cost");
-
-    SimplePath<FullGraph> path;
-    alg.tour(path);
-    check(path.length() == esize, alg_name + ": Wrong tour");
-    check(checkTourPath(g, path), alg_name + ": Wrong tour");
-    check(checkCost(g, path, constMap<Edge, int>(1), esize),
-      alg_name + ": Wrong tour cost");
-  }
-}
-
-// Tests a TSP algorithm on random graphs
-template <typename TSP>
-void tspTestRandom(const std::string &alg_name) {
-  GRAPH_TYPEDEFS(FullGraph);
-
-  FullGraph g(20);
-  FullGraph::NodeMap<dim2::Point<double> > pos(g);
-  DoubleEdgeMap cost(g);
-
-  TSP alg(g, cost);
-  Opt2Tsp<DoubleEdgeMap > opt2(g, cost);
-
-  for (int i = 1; i <= 3; i++) {
-    for (NodeIt u(g); u != INVALID; ++u) {
-      pos[u] = dim2::Point<double>(rnd(), rnd());
-    }
-    for (NodeIt u(g); u != INVALID; ++u) {
-      for (NodeIt v(g); v != INVALID; ++v) {
-        if (u == v) continue;
-        cost[g.edge(u, v)] = (pos[u] - pos[v]).normSquare();
-      }
-    }
-
-    check(alg.run() > 0, alg_name + ": Wrong total cost");
-
-    std::vector<Node> vec;
-    alg.tourNodes(std::back_inserter(vec));
-    check(checkTour(g, vec), alg_name + ": Wrong node sequence");
-    check(checkCost(g, vec, cost, alg.tourCost()),
-      alg_name + ": Wrong tour cost");
-
-    SimplePath<FullGraph> path;
-    alg.tour(path);
-    check(checkTourPath(g, path), alg_name + ": Wrong tour");
-    check(checkCost(g, path, cost, alg.tourCost()),
-      alg_name + ": Wrong tour cost");
-
-    check(!Tolerance<double>().less(alg.tourCost(), opt2.run(alg.tourNodes())),
-      "2-opt improvement: Wrong total cost");
-    check(checkTour(g, opt2.tourNodes()),
-      "2-opt improvement: Wrong node sequence");
-    check(checkCost(g, opt2.tourNodes(), cost, opt2.tourCost()),
-      "2-opt improvement: Wrong tour cost");
-
-    check(!Tolerance<double>().less(alg.tourCost(), opt2.run(path)),
-      "2-opt improvement: Wrong total cost");
-    check(checkTour(g, opt2.tourNodes()),
-      "2-opt improvement: Wrong node sequence");
-    check(checkCost(g, opt2.tourNodes(), cost, opt2.tourCost()),
-      "2-opt improvement: Wrong tour cost");
-  }
-}
-
-// Algorithm class for Nearest Insertion
-template <typename CM>
-class NearestInsertionTsp : public InsertionTsp<CM> {
-public:
-  NearestInsertionTsp(const FullGraph &gr, const CM &cost)
-    : InsertionTsp<CM>(gr, cost) {}
-  typename CM::Value run() {
-    return InsertionTsp<CM>::run(InsertionTsp<CM>::NEAREST);
-  }
-};
-
-// Algorithm class for Farthest Insertion
-template <typename CM>
-class FarthestInsertionTsp : public InsertionTsp<CM> {
-public:
-  FarthestInsertionTsp(const FullGraph &gr, const CM &cost)
-    : InsertionTsp<CM>(gr, cost) {}
-  typename CM::Value run() {
-    return InsertionTsp<CM>::run(InsertionTsp<CM>::FARTHEST);
-  }
-};
-
-// Algorithm class for Cheapest Insertion
-template <typename CM>
-class CheapestInsertionTsp : public InsertionTsp<CM> {
-public:
-  CheapestInsertionTsp(const FullGraph &gr, const CM &cost)
-    : InsertionTsp<CM>(gr, cost) {}
-  typename CM::Value run() {
-    return InsertionTsp<CM>::run(InsertionTsp<CM>::CHEAPEST);
-  }
-};
-
-// Algorithm class for Random Insertion
-template <typename CM>
-class RandomInsertionTsp : public InsertionTsp<CM> {
-public:
-  RandomInsertionTsp(const FullGraph &gr, const CM &cost)
-    : InsertionTsp<CM>(gr, cost) {}
-  typename CM::Value run() {
-    return InsertionTsp<CM>::run(InsertionTsp<CM>::RANDOM);
-  }
-};
-
-int main() {
-  GRAPH_TYPEDEFS(FullGraph);
-
-  // metricCostTest();
-
-  tspTestSmall<NearestNeighborTsp<ConstMap<Edge, int> > >("Nearest Neighbor");
-  tspTestSmall<GreedyTsp<ConstMap<Edge, int> > >("Greedy");
-  tspTestSmall<NearestInsertionTsp<ConstMap<Edge, int> > >("Nearest Insertion");
-  tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >
-    ("Farthest Insertion");
-  tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >
-    ("Cheapest Insertion");
-  tspTestSmall<RandomInsertionTsp<ConstMap<Edge, int> > >("Random Insertion");
-  tspTestSmall<ChristofidesTsp<ConstMap<Edge, int> > >("Christofides");
-  tspTestSmall<Opt2Tsp<ConstMap<Edge, int> > >("2-opt");
-
-  tspTestRandom<NearestNeighborTsp<DoubleEdgeMap > >("Nearest Neighbor");
-  tspTestRandom<GreedyTsp<DoubleEdgeMap > >("Greedy");
-  tspTestRandom<NearestInsertionTsp<DoubleEdgeMap > >("Nearest Insertion");
-  tspTestRandom<FarthestInsertionTsp<DoubleEdgeMap > >("Farthest Insertion");
-  tspTestRandom<CheapestInsertionTsp<DoubleEdgeMap > >("Cheapest Insertion");
-  tspTestRandom<RandomInsertionTsp<DoubleEdgeMap > >("Random Insertion");
-  tspTestRandom<ChristofidesTsp<DoubleEdgeMap > >("Christofides");
-  tspTestRandom<Opt2Tsp<DoubleEdgeMap > >("2-opt");
-
-  return 0;
-}
