Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 278)
+++ test/bfs_test.cc	(revision 286)
@@ -55,25 +55,50 @@
   typedef concepts::Digraph Digraph;
   typedef Bfs<Digraph> BType;
+  typedef Digraph::Node Node;
+  typedef Digraph::Arc Arc;
 
   Digraph G;
-  Digraph::Node n;
-  Digraph::Arc e;
+  Node s, t;
+  Arc e;
   int l;
   bool b;
   BType::DistMap d(G);
   BType::PredMap p(G);
+  Path<Digraph> pp;
 
-  BType bfs_test(G);
+  {
+    BType bfs_test(G);
 
-  bfs_test.run(n);
+    bfs_test.run(s);
+    bfs_test.run(s,t);
+    bfs_test.run();
 
-  l  = bfs_test.dist(n);
-  e  = bfs_test.predArc(n);
-  n  = bfs_test.predNode(n);
-  d  = bfs_test.distMap();
-  p  = bfs_test.predMap();
-  b  = bfs_test.reached(n);
+    l  = bfs_test.dist(t);
+    e  = bfs_test.predArc(t);
+    s  = bfs_test.predNode(t);
+    b  = bfs_test.reached(t);
+    d  = bfs_test.distMap();
+    p  = bfs_test.predMap();
+    pp = bfs_test.path(t);
+  }
+  {
+    BType
+      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
+      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
+      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
+      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
+      ::SetStandardProcessedMap
+      ::Create bfs_test(G);
 
-  Path<Digraph> pp = bfs_test.path(n);
+    bfs_test.run(s);
+    bfs_test.run(s,t);
+    bfs_test.run();
+
+    l  = bfs_test.dist(t);
+    e  = bfs_test.predArc(t);
+    s  = bfs_test.predNode(t);
+    b  = bfs_test.reached(t);
+    pp = bfs_test.path(t);
+  }
 }
 
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 278)
+++ test/dfs_test.cc	(revision 286)
@@ -57,25 +57,50 @@
   typedef concepts::Digraph Digraph;
   typedef Dfs<Digraph> DType;
+  typedef Digraph::Node Node;
+  typedef Digraph::Arc Arc;
 
   Digraph G;
-  Digraph::Node n;
-  Digraph::Arc e;
+  Node s, t;
+  Arc e;
   int l;
   bool b;
   DType::DistMap d(G);
   DType::PredMap p(G);
+  Path<Digraph> pp;
 
-  DType dfs_test(G);
+  {
+    DType dfs_test(G);
 
-  dfs_test.run(n);
+    dfs_test.run(s);
+    dfs_test.run(s,t);
+    dfs_test.run();
 
-  l  = dfs_test.dist(n);
-  e  = dfs_test.predArc(n);
-  n  = dfs_test.predNode(n);
-  d  = dfs_test.distMap();
-  p  = dfs_test.predMap();
-  b  = dfs_test.reached(n);
+    l  = dfs_test.dist(t);
+    e  = dfs_test.predArc(t);
+    s  = dfs_test.predNode(t);
+    b  = dfs_test.reached(t);
+    d  = dfs_test.distMap();
+    p  = dfs_test.predMap();
+    pp = dfs_test.path(t);
+  }
+  {
+    DType
+      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
+      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
+      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
+      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
+      ::SetStandardProcessedMap
+      ::Create dfs_test(G);
 
-  Path<Digraph> pp = dfs_test.path(n);
+    dfs_test.run(s);
+    dfs_test.run(s,t);
+    dfs_test.run();
+
+    l  = dfs_test.dist(t);
+    e  = dfs_test.predArc(t);
+    s  = dfs_test.predNode(t);
+    b  = dfs_test.reached(t);
+    pp = dfs_test.path(t);
+  }
 }
 
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 278)
+++ test/dijkstra_test.cc	(revision 286)
@@ -23,4 +23,5 @@
 #include <lemon/dijkstra.h>
 #include <lemon/path.h>
+#include <lemon/bin_heap.h>
 
 #include "graph_test.h"
@@ -56,8 +57,10 @@
   typedef concepts::ReadMap<Digraph::Arc,VType> LengthMap;
   typedef Dijkstra<Digraph, LengthMap> DType;
+  typedef Digraph::Node Node;
+  typedef Digraph::Arc Arc;
 
   Digraph G;
-  Digraph::Node n;
-  Digraph::Arc e;
+  Node s, t;
+  Arc e;
   VType l;
   bool b;
@@ -65,17 +68,41 @@
   DType::PredMap p(G);
   LengthMap length;
+  Path<Digraph> pp;
 
-  DType dijkstra_test(G,length);
+  {
+    DType dijkstra_test(G,length);
 
-  dijkstra_test.run(n);
+    dijkstra_test.run(s);
+    dijkstra_test.run(s,t);
 
-  l  = dijkstra_test.dist(n);
-  e  = dijkstra_test.predArc(n);
-  n  = dijkstra_test.predNode(n);
-  d  = dijkstra_test.distMap();
-  p  = dijkstra_test.predMap();
-  b  = dijkstra_test.reached(n);
+    l  = dijkstra_test.dist(t);
+    e  = dijkstra_test.predArc(t);
+    s  = dijkstra_test.predNode(t);
+    b  = dijkstra_test.reached(t);
+    d  = dijkstra_test.distMap();
+    p  = dijkstra_test.predMap();
+    pp = dijkstra_test.path(t);
+  }
+  {
+    DType
+      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
+      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
+      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
+      ::SetStandardProcessedMap
+      ::SetOperationTraits<DijkstraWidestPathOperationTraits<VType> >
+      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
+      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
+      ::Create dijkstra_test(G,length);
 
-  Path<Digraph> pp = dijkstra_test.path(n);
+    dijkstra_test.run(s);
+    dijkstra_test.run(s,t);
+
+    l  = dijkstra_test.dist(t);
+    e  = dijkstra_test.predArc(t);
+    s  = dijkstra_test.predNode(t);
+    b  = dijkstra_test.reached(t);
+    pp = dijkstra_test.path(t);
+  }
+
 }
 
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 282)
+++ test/graph_copy_test.cc	(revision 220)
@@ -64,9 +64,9 @@
   ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);
 
-  digraphCopy(from, to).
-    nodeMap(fnm, tnm).arcMap(fam, tam).
+  DigraphCopy<ListDigraph, SmartDigraph>(to, from).
+    nodeMap(tnm, fnm).arcMap(tam, fam).
     nodeRef(nr).arcRef(er).
     nodeCrossRef(ncr).arcCrossRef(ecr).
-    node(fn, tn).arc(fa, ta).run();
+    node(tn, fn).arc(ta, fa).run();
 
   for (SmartDigraph::NodeIt it(from); it != INVALID; ++it) {
@@ -139,9 +139,9 @@
   ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);
 
-  graphCopy(from, to).
-    nodeMap(fnm, tnm).arcMap(fam, tam).edgeMap(fem, tem).
+  GraphCopy<ListGraph, SmartGraph>(to, from).
+    nodeMap(tnm, fnm).arcMap(tam, fam).edgeMap(tem, fem).
     nodeRef(nr).arcRef(ar).edgeRef(er).
     nodeCrossRef(ncr).arcCrossRef(acr).edgeCrossRef(ecr).
-    node(fn, tn).arc(fa, ta).edge(fe, te).run();
+    node(tn, fn).arc(ta, fa).edge(te, fe).run();
 
   for (SmartGraph::NodeIt it(from); it != INVALID; ++it) {
