Index: src/lemon/skeletons/graph.h
===================================================================
--- src/lemon/skeletons/graph.h	(revision 921)
+++ src/lemon/skeletons/graph.h	(revision 938)
@@ -46,4 +46,7 @@
     /// like @ref ListGraph or
     /// @ref SmartGraph will just refer to this structure.
+    ///
+    /// \todo A pages describing the concept of concept description would
+    /// be nice.
     class StaticGraph
     {
@@ -443,8 +446,204 @@
     };
 
-
+    struct DummyType {
+      int value;
+      DummyType() {}
+      DummyType(int p) : value(p) {}
+      DummyType& operator=(int p) { value = p; return *this;}
+    };
+    
+    ///\brief Checks whether \c G meets the
+    ///\ref lemon::skeleton::StaticGraph "StaticGraph" concept
+    template<class Graph> void checkCompileStaticGraph(Graph &G) 
+    {
+      typedef typename Graph::Node Node;
+      typedef typename Graph::NodeIt NodeIt;
+      typedef typename Graph::Edge Edge;
+      typedef typename Graph::EdgeIt EdgeIt;
+      typedef typename Graph::InEdgeIt InEdgeIt;
+      typedef typename Graph::OutEdgeIt OutEdgeIt;
   
+      {
+	Node i; Node j(i); Node k(INVALID);
+	i=j;
+	bool b; b=true;
+	b=(i==INVALID); b=(i!=INVALID);
+	b=(i==j); b=(i!=j); b=(i<j);
+      }
+      {
+	NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G);
+	i=j;
+	j=G.first(i);
+	j=++i;
+	bool b; b=true;
+	b=(i==INVALID); b=(i!=INVALID);
+	Node n(i);
+	n=i;
+	b=(i==j); b=(i!=j); b=(i<j);
+	//Node ->NodeIt conversion
+	NodeIt ni(G,n);
+      }
+      {
+	Edge i; Edge j(i); Edge k(INVALID);
+	i=j;
+	bool b; b=true;
+	b=(i==INVALID); b=(i!=INVALID);
+	b=(i==j); b=(i!=j); b=(i<j);
+      }
+      {
+	EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G);
+	i=j;
+	j=G.first(i);
+	j=++i;
+	bool b; b=true;
+	b=(i==INVALID); b=(i!=INVALID);
+	Edge e(i);
+	e=i;
+	b=(i==j); b=(i!=j); b=(i<j);
+	//Edge ->EdgeIt conversion
+	EdgeIt ei(G,e);
+      }
+      {
+	Node n;
+	InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n);
+	i=j;
+	j=G.first(i,n);
+	j=++i;
+	bool b; b=true;
+	b=(i==INVALID); b=(i!=INVALID);
+	Edge e(i);
+	e=i;
+	b=(i==j); b=(i!=j); b=(i<j);
+	//Edge ->InEdgeIt conversion
+	InEdgeIt ei(G,e);
+      }
+      {
+	Node n;
+	OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n);
+	i=j;
+	j=G.first(i,n);
+	j=++i;
+	bool b; b=true;
+	b=(i==INVALID); b=(i!=INVALID);
+	Edge e(i);
+	e=i;
+	b=(i==j); b=(i!=j); b=(i<j);
+	//Edge ->OutEdgeIt conversion
+	OutEdgeIt ei(G,e);
+      }
+      {
+	Node n,m;
+	n=m=INVALID;
+	Edge e;
+	e=INVALID;
+	n=G.tail(e);
+	n=G.head(e);
+      }
+      // id tests
+      { Node n; int i=G.id(n); i=i; }
+      { Edge e; int i=G.id(e); i=i; }
+      //NodeMap tests
+      {
+	Node k;
+	typename Graph::template NodeMap<int> m(G);
+	//Const map
+	typename Graph::template NodeMap<int> const &cm = m;
+	//Inicialize with default value
+	typename Graph::template NodeMap<int> mdef(G,12);
+	//Copy
+	typename Graph::template NodeMap<int> mm(cm);
+	//Copy from another type
+	typename Graph::template NodeMap<double> dm(cm);
+	//Copy to more complex type
+	typename Graph::template NodeMap<DummyType> em(cm);
+	int v;
+	v=m[k]; m[k]=v; m.set(k,v);
+	v=cm[k];
+    
+	m=cm;  
+	dm=cm; //Copy from another type  
+	em=cm; //Copy to more complex type
+	{
+	  //Check the typedef's
+	  typename Graph::template NodeMap<int>::ValueType val;
+	  val=1;
+	  typename Graph::template NodeMap<int>::KeyType key;
+	  key = typename Graph::NodeIt(G);
+	}
+      }  
+      { //bool NodeMap
+	Node k;
+	typename Graph::template NodeMap<bool> m(G);
+	typename Graph::template NodeMap<bool> const &cm = m;  //Const map
+	//Inicialize with default value
+	typename Graph::template NodeMap<bool> mdef(G,12);
+	typename Graph::template NodeMap<bool> mm(cm);   //Copy
+	typename Graph::template NodeMap<int> dm(cm); //Copy from another type
+	bool v;
+	v=m[k]; m[k]=v; m.set(k,v);
+	v=cm[k];
+    
+	m=cm;  
+	dm=cm; //Copy from another type
+	m=dm; //Copy to another type
+
+	{
+	  //Check the typedef's
+	  typename Graph::template NodeMap<bool>::ValueType val;
+	  val=true;
+	  typename Graph::template NodeMap<bool>::KeyType key;
+	  key= typename Graph::NodeIt(G);
+	}
+      }
+      //EdgeMap tests
+      {
+	Edge k;
+	typename Graph::template EdgeMap<int> m(G);
+	typename Graph::template EdgeMap<int> const &cm = m;  //Const map
+	//Inicialize with default value
+	typename Graph::template EdgeMap<int> mdef(G,12);
+	typename Graph::template EdgeMap<int> mm(cm);   //Copy
+	typename Graph::template EdgeMap<double> dm(cm);//Copy from another type
+	int v;
+	v=m[k]; m[k]=v; m.set(k,v);
+	v=cm[k];
+    
+	m=cm;  
+	dm=cm; //Copy from another type
+	{
+	  //Check the typedef's
+	  typename Graph::template EdgeMap<int>::ValueType val;
+	  val=1;
+	  typename Graph::template EdgeMap<int>::KeyType key;
+	  key= typename Graph::EdgeIt(G);
+	}
+      }  
+      { //bool EdgeMap
+	Edge k;
+	typename Graph::template EdgeMap<bool> m(G);
+	typename Graph::template EdgeMap<bool> const &cm = m;  //Const map
+	//Inicialize with default value
+	typename Graph::template EdgeMap<bool> mdef(G,12);
+	typename Graph::template EdgeMap<bool> mm(cm);   //Copy
+	typename Graph::template EdgeMap<int> dm(cm); //Copy from another type
+	bool v;
+	v=m[k]; m[k]=v; m.set(k,v);
+	v=cm[k];
+    
+	m=cm;  
+	dm=cm; //Copy from another type
+	m=dm; //Copy to another type
+	{
+	  //Check the typedef's
+	  typename Graph::template EdgeMap<bool>::ValueType val;
+	  val=true;
+	  typename Graph::template EdgeMap<bool>::KeyType key;
+	  key= typename Graph::EdgeIt(G);
+	}
+      }
+    }
+    
     /// An empty non-static graph class.
-
+    
     /// This class provides everything that \ref StaticGraph
     /// with additional functionality which enables to build a
@@ -478,4 +677,28 @@
     };
 
+    
+    ///\brief Checks whether \c G meets the
+    ///\ref lemon::skeleton::ExtendableGraph "ExtendableGraph" concept
+    template<class Graph> void checkCompileExtendableGraph(Graph &G) 
+    {
+      checkCompileStaticGraph(G);
+
+      typedef typename Graph::Node Node;
+      typedef typename Graph::NodeIt NodeIt;
+      typedef typename Graph::Edge Edge;
+      typedef typename Graph::EdgeIt EdgeIt;
+      typedef typename Graph::InEdgeIt InEdgeIt;
+      typedef typename Graph::OutEdgeIt OutEdgeIt;
+  
+      Node n,m;
+      n=G.addNode();
+      m=G.addNode();
+      Edge e;
+      e=G.addEdge(n,m); 
+  
+      //  G.clear();
+    }
+
+
     /// An empty erasable graph class.
   
@@ -501,5 +724,39 @@
       void erase(Edge e) { }
     };
-
+    
+    template<class Graph> void checkCompileGraphEraseEdge(Graph &G) 
+    {
+      typename Graph::Edge e;
+      G.erase(e);
+    }
+
+    template<class Graph> void checkCompileGraphEraseNode(Graph &G) 
+    {
+      typename Graph::Node n;
+      G.erase(n);
+    }
+
+    ///\brief Checks whether \c G meets the
+    ///\ref lemon::skeleton::EresableGraph "EresableGraph" concept
+    template<class Graph> void checkCompileErasableGraph(Graph &G) 
+    {
+      checkCompileExtendableGraph(G);
+      checkCompileGraphEraseNode(G);
+      checkCompileGraphEraseEdge(G);
+    }
+
+    ///Checks whether a graph has findEdge() member function.
+    
+    ///\todo findEdge() might be a global function.
+    ///
+    template<class Graph> void checkCompileGraphFindEdge(Graph &G) 
+    {
+      typedef typename Graph::NodeIt Node;
+      typedef typename Graph::NodeIt NodeIt;
+
+      G.findEdge(NodeIt(G),++NodeIt(G),G.findEdge(NodeIt(G),++NodeIt(G)));
+      G.findEdge(Node(),Node(),G.findEdge(Node(),Node()));  
+    }
+ 
     // @}
   } //namespace skeleton  
Index: src/test/Makefile.am
===================================================================
--- src/test/Makefile.am	(revision 937)
+++ src/test/Makefile.am	(revision 938)
@@ -3,5 +3,5 @@
 EXTRA_DIST = preflow_graph.dim #input file for preflow_test.cc
 
-noinst_HEADERS = test_tools.h graph_test.h
+noinst_HEADERS = test_tools.h graph_test.h sym_graph_test.h
 
 check_PROGRAMS = \
Index: src/test/graph_test.cc
===================================================================
--- src/test/graph_test.cc	(revision 937)
+++ src/test/graph_test.cc	(revision 938)
@@ -68,16 +68,20 @@
 
 //Compile Graph
-template void lemon::checkCompileStaticGraph<skeleton::StaticGraph>
+template void lemon::skeleton::checkCompileStaticGraph<skeleton::StaticGraph>
 (skeleton::StaticGraph &);
 
-template void lemon::checkCompileGraph<skeleton::ExtendableGraph>
+template
+void lemon::skeleton::checkCompileExtendableGraph<skeleton::ExtendableGraph>
 (skeleton::ExtendableGraph &);
 
-template void lemon::checkCompileErasableGraph<skeleton::ErasableGraph>
+template
+void lemon::skeleton::checkCompileErasableGraph<skeleton::ErasableGraph>
 (skeleton::ErasableGraph &);
 
 //Compile SmartGraph
-template void lemon::checkCompileGraph<SmartGraph>(SmartGraph &);
-template void lemon::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
+template
+void lemon::skeleton::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
 
 //Compile SymSmartGraph
@@ -86,7 +90,10 @@
 
 //Compile ListGraph
-template void lemon::checkCompileGraph<ListGraph>(ListGraph &);
-template void lemon::checkCompileErasableGraph<ListGraph>(ListGraph &);
-template void lemon::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
+template
+void lemon::skeleton::checkCompileExtendableGraph<ListGraph>(ListGraph &);
+template
+void lemon::skeleton::checkCompileErasableGraph<ListGraph>(ListGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
 
 
@@ -97,20 +104,22 @@
 
 //Compile FullGraph
-template void lemon::checkCompileStaticGraph<FullGraph>(FullGraph &);
-template void lemon::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
+template void lemon::skeleton::checkCompileStaticGraph<FullGraph>(FullGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
 
 //Compile EdgeSet <ListGraph>
-template void lemon::checkCompileGraph<EdgeSet <ListGraph> >
+template void lemon::skeleton::checkCompileExtendableGraph<EdgeSet <ListGraph> >
 (EdgeSet <ListGraph> &);
-template void lemon::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
+template void lemon::skeleton::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
 (EdgeSet <ListGraph> &);
-template void lemon::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
+template void lemon::skeleton::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
 (EdgeSet <ListGraph> &);
 
 //Compile EdgeSet <NodeSet>
-template void lemon::checkCompileGraph<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
-template void lemon::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
+template void lemon::skeleton::checkCompileExtendableGraph<EdgeSet <NodeSet> >
 (EdgeSet <NodeSet> &);
-template void lemon::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
+template void lemon::skeleton::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
+(EdgeSet <NodeSet> &);
+template void lemon::skeleton::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
 (EdgeSet <NodeSet> &);
 
Index: src/test/graph_test.h
===================================================================
--- src/test/graph_test.h	(revision 937)
+++ src/test/graph_test.h	(revision 938)
@@ -24,249 +24,4 @@
 //! \brief Some utility to  test graph classes.
 namespace lemon {
-
-  struct DummyType {
-    int value;
-    DummyType() {}
-    DummyType(int p) : value(p) {}
-    DummyType& operator=(int p) { value = p; return *this;}
-  };
-
-
-  template<class Graph> void checkCompileStaticGraph(Graph &G) 
-    {
-      typedef typename Graph::Node Node;
-      typedef typename Graph::NodeIt NodeIt;
-      typedef typename Graph::Edge Edge;
-      typedef typename Graph::EdgeIt EdgeIt;
-      typedef typename Graph::InEdgeIt InEdgeIt;
-      typedef typename Graph::OutEdgeIt OutEdgeIt;
-  
-      {
-	Node i; Node j(i); Node k(INVALID);
-	i=j;
-	bool b; b=true;
-	b=(i==INVALID); b=(i!=INVALID);
-	b=(i==j); b=(i!=j); b=(i<j);
-      }
-      {
-	NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G);
-	i=j;
-	j=G.first(i);
-	j=++i;
-	bool b; b=true;
-	b=(i==INVALID); b=(i!=INVALID);
-	Node n(i);
-	n=i;
-	b=(i==j); b=(i!=j); b=(i<j);
-	//Node ->NodeIt conversion
-	NodeIt ni(G,n);
-      }
-      {
-	Edge i; Edge j(i); Edge k(INVALID);
-	i=j;
-	bool b; b=true;
-	b=(i==INVALID); b=(i!=INVALID);
-	b=(i==j); b=(i!=j); b=(i<j);
-      }
-      {
-	EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G);
-	i=j;
-	j=G.first(i);
-	j=++i;
-	bool b; b=true;
-	b=(i==INVALID); b=(i!=INVALID);
-	Edge e(i);
-	e=i;
-	b=(i==j); b=(i!=j); b=(i<j);
-	//Edge ->EdgeIt conversion
-	EdgeIt ei(G,e);
-      }
-      {
-	Node n;
-	InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n);
-	i=j;
-	j=G.first(i,n);
-	j=++i;
-	bool b; b=true;
-	b=(i==INVALID); b=(i!=INVALID);
-	Edge e(i);
-	e=i;
-	b=(i==j); b=(i!=j); b=(i<j);
-	//Edge ->InEdgeIt conversion
-	InEdgeIt ei(G,e);
-      }
-      {
-	Node n;
-	OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n);
-	i=j;
-	j=G.first(i,n);
-	j=++i;
-	bool b; b=true;
-	b=(i==INVALID); b=(i!=INVALID);
-	Edge e(i);
-	e=i;
-	b=(i==j); b=(i!=j); b=(i<j);
-	//Edge ->OutEdgeIt conversion
-	OutEdgeIt ei(G,e);
-      }
-      {
-	Node n,m;
-	n=m=INVALID;
-	Edge e;
-	e=INVALID;
-	n=G.tail(e);
-	n=G.head(e);
-      }
-      // id tests
-      { Node n; int i=G.id(n); i=i; }
-      { Edge e; int i=G.id(e); i=i; }
-      //NodeMap tests
-      {
-	Node k;
-	typename Graph::template NodeMap<int> m(G);
-	//Const map
-	typename Graph::template NodeMap<int> const &cm = m;
-	//Inicialize with default value
-	typename Graph::template NodeMap<int> mdef(G,12);
-	//Copy
-	typename Graph::template NodeMap<int> mm(cm);
-	//Copy from another type
-	typename Graph::template NodeMap<double> dm(cm);
-	//Copy to more complex type
-	typename Graph::template NodeMap<DummyType> em(cm);
-	int v;
-	v=m[k]; m[k]=v; m.set(k,v);
-	v=cm[k];
-    
-	m=cm;  
-	dm=cm; //Copy from another type  
-	em=cm; //Copy to more complex type
-	{
-	  //Check the typedef's
-	  typename Graph::template NodeMap<int>::ValueType val;
-	  val=1;
-	  typename Graph::template NodeMap<int>::KeyType key;
-	  key = typename Graph::NodeIt(G);
-	}
-      }  
-      { //bool NodeMap
-	Node k;
-	typename Graph::template NodeMap<bool> m(G);
-	typename Graph::template NodeMap<bool> const &cm = m;  //Const map
-	//Inicialize with default value
-	typename Graph::template NodeMap<bool> mdef(G,12);
-	typename Graph::template NodeMap<bool> mm(cm);   //Copy
-	typename Graph::template NodeMap<int> dm(cm); //Copy from another type
-	bool v;
-	v=m[k]; m[k]=v; m.set(k,v);
-	v=cm[k];
-    
-	m=cm;  
-	dm=cm; //Copy from another type
-	m=dm; //Copy to another type
-
-	{
-	  //Check the typedef's
-	  typename Graph::template NodeMap<bool>::ValueType val;
-	  val=true;
-	  typename Graph::template NodeMap<bool>::KeyType key;
-	  key= typename Graph::NodeIt(G);
-	}
-      }
-      //EdgeMap tests
-      {
-	Edge k;
-	typename Graph::template EdgeMap<int> m(G);
-	typename Graph::template EdgeMap<int> const &cm = m;  //Const map
-	//Inicialize with default value
-	typename Graph::template EdgeMap<int> mdef(G,12);
-	typename Graph::template EdgeMap<int> mm(cm);   //Copy
-	typename Graph::template EdgeMap<double> dm(cm); //Copy from another type
-	int v;
-	v=m[k]; m[k]=v; m.set(k,v);
-	v=cm[k];
-    
-	m=cm;  
-	dm=cm; //Copy from another type
-	{
-	  //Check the typedef's
-	  typename Graph::template EdgeMap<int>::ValueType val;
-	  val=1;
-	  typename Graph::template EdgeMap<int>::KeyType key;
-	  key= typename Graph::EdgeIt(G);
-	}
-      }  
-      { //bool EdgeMap
-	Edge k;
-	typename Graph::template EdgeMap<bool> m(G);
-	typename Graph::template EdgeMap<bool> const &cm = m;  //Const map
-	//Inicialize with default value
-	typename Graph::template EdgeMap<bool> mdef(G,12);
-	typename Graph::template EdgeMap<bool> mm(cm);   //Copy
-	typename Graph::template EdgeMap<int> dm(cm); //Copy from another type
-	bool v;
-	v=m[k]; m[k]=v; m.set(k,v);
-	v=cm[k];
-    
-	m=cm;  
-	dm=cm; //Copy from another type
-	m=dm; //Copy to another type
-	{
-	  //Check the typedef's
-	  typename Graph::template EdgeMap<bool>::ValueType val;
-	  val=true;
-	  typename Graph::template EdgeMap<bool>::KeyType key;
-	  key= typename Graph::EdgeIt(G);
-	}
-      }
-    }
-
-  template<class Graph> void checkCompileGraph(Graph &G) 
-    {
-      checkCompileStaticGraph(G);
-
-      typedef typename Graph::Node Node;
-      typedef typename Graph::NodeIt NodeIt;
-      typedef typename Graph::Edge Edge;
-      typedef typename Graph::EdgeIt EdgeIt;
-      typedef typename Graph::InEdgeIt InEdgeIt;
-      typedef typename Graph::OutEdgeIt OutEdgeIt;
-  
-      Node n,m;
-      n=G.addNode();
-      m=G.addNode();
-      Edge e;
-      e=G.addEdge(n,m); 
-  
-      //  G.clear();
-    }
-
-  template<class Graph> void checkCompileGraphEraseEdge(Graph &G) 
-    {
-      typename Graph::Edge e;
-      G.erase(e);
-    }
-
-  template<class Graph> void checkCompileGraphEraseNode(Graph &G) 
-    {
-      typename Graph::Node n;
-      G.erase(n);
-    }
-
-  template<class Graph> void checkCompileErasableGraph(Graph &G) 
-    {
-      checkCompileGraph(G);
-      checkCompileGraphEraseNode(G);
-      checkCompileGraphEraseEdge(G);
-    }
-
-  template<class Graph> void checkCompileGraphFindEdge(Graph &G) 
-    {
-      typedef typename Graph::NodeIt Node;
-      typedef typename Graph::NodeIt NodeIt;
-
-      G.findEdge(NodeIt(G),++NodeIt(G),G.findEdge(NodeIt(G),++NodeIt(G)));
-      G.findEdge(Node(),Node(),G.findEdge(Node(),Node()));  
-    }
 
   template<class Graph> void checkGraphNodeList(Graph &G, int nn)
Index: src/test/graph_wrapper_test.cc
===================================================================
--- src/test/graph_wrapper_test.cc	(revision 933)
+++ src/test/graph_wrapper_test.cc	(revision 938)
@@ -39,22 +39,22 @@
 //Compile GraphWrapper
 typedef GraphWrapper<Graph> GW;
-template void checkCompileStaticGraph<GW>(GW &);
+template void lemon::skeleton::checkCompileStaticGraph<GW>(GW &);
 
 //Compile RevGraphWrapper
 typedef RevGraphWrapper<Graph> RevGW;
-template void checkCompileStaticGraph<RevGW>(RevGW &);
+template void lemon::skeleton::checkCompileStaticGraph<RevGW>(RevGW &);
 
 //Compile SubGraphWrapper
 typedef SubGraphWrapper<Graph, Graph::NodeMap<bool>, 
 			Graph::EdgeMap<bool> > SubGW;
-template void checkCompileStaticGraph<SubGW>(SubGW &);
+template void lemon::skeleton::checkCompileStaticGraph<SubGW>(SubGW &);
 
 //Compile NodeSubGraphWrapper
 typedef NodeSubGraphWrapper<Graph, Graph::NodeMap<bool> > NodeSubGW;
-template void checkCompileStaticGraph<NodeSubGW>(NodeSubGW &);
+template void lemon::skeleton::checkCompileStaticGraph<NodeSubGW>(NodeSubGW &);
 
 //Compile EdgeSubGraphWrapper
 typedef EdgeSubGraphWrapper<Graph, Graph::EdgeMap<bool> > EdgeSubGW;
-template void checkCompileStaticGraph<EdgeSubGW>(EdgeSubGW &);
+template void lemon::skeleton::checkCompileStaticGraph<EdgeSubGW>(EdgeSubGW &);
 
 //Compile UndirGraphWrapper
@@ -70,22 +70,23 @@
 typedef SubBidirGraphWrapper<Graph, Graph::EdgeMap<bool>, 
 			     Graph::EdgeMap<bool> > SubBDGW;
-template void checkCompileStaticGraph<SubBDGW>(SubBDGW &);
+template void lemon::skeleton::checkCompileStaticGraph<SubBDGW>(SubBDGW &);
 
 //Compile BidirGraphWrapper
 typedef BidirGraphWrapper<Graph> BidirGW;
-template void checkCompileStaticGraph<BidirGW>(BidirGW &);
+template void lemon::skeleton::checkCompileStaticGraph<BidirGW>(BidirGW &);
 
 //Compile BidirGraph
 typedef BidirGraph<Graph> BidirG;
-template void checkCompileStaticGraph<BidirG>(BidirG &);
+template void lemon::skeleton::checkCompileStaticGraph<BidirG>(BidirG &);
 
 //Compile ResGraphWrapper
 typedef ResGraphWrapper<Graph, int, Graph::EdgeMap<int>, 
 			Graph::EdgeMap<int> > ResGW;
-template void checkCompileStaticGraph<ResGW>(ResGW &);
+template void lemon::skeleton::checkCompileStaticGraph<ResGW>(ResGW &);
 
 //Compile ErasingFirstGraphWrapper
 typedef ErasingFirstGraphWrapper<Graph, Graph::NodeMap<Graph::Edge> > ErasingFirstGW;
-template void checkCompileStaticGraph<ErasingFirstGW>(ErasingFirstGW &);
+template
+void lemon::skeleton::checkCompileStaticGraph<ErasingFirstGW>(ErasingFirstGW &);
 
 
Index: src/test/sym_graph_test.cc
===================================================================
--- src/test/sym_graph_test.cc	(revision 937)
+++ src/test/sym_graph_test.cc	(revision 938)
@@ -67,10 +67,12 @@
 //Compile SymSmartGraph
 template void lemon::checkCompileSymGraph<SymSmartGraph>(SymSmartGraph &);
-template void lemon::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
 
 //Compile SymListGraph
 template void lemon::checkCompileSymGraph<SymListGraph>(SymListGraph &);
 template void lemon::checkCompileErasableSymGraph<SymListGraph>(SymListGraph &);
-template void lemon::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
 
 int main() 
Index: src/test/sym_graph_test.h
===================================================================
--- src/test/sym_graph_test.h	(revision 937)
+++ src/test/sym_graph_test.h	(revision 938)
@@ -25,5 +25,9 @@
 //! \brief Some utility to test symmetric graph classes.
 namespace lemon {
+  
+  /// \e
 
+  /// \todo This should go to lemon/skeleton/symgraph.h
+  ///
   template<class Graph> void checkCompileStaticSymGraph(Graph &G) 
     {
@@ -37,5 +41,5 @@
       typedef typename Graph::OutEdgeIt OutEdgeIt;
 
-      checkCompileStaticGraph(G);
+      lemon::skeleton::checkCompileStaticGraph(G);
   
       {
@@ -154,5 +158,5 @@
     {
       checkCompileSymGraph(G);
-      checkCompileGraphEraseNode(G);
+      lemon::skeleton::checkCompileGraphEraseNode(G);
       checkCompileSymGraphEraseSymEdge(G);
     }
