#include<iostream>

#include<hugo/smart_graph.h>

#include<hugo/skeletons/graph.h>

#include<hugo/list_graph.h>

#include<hugo/full_graph.h>

#include<hugo/graph_wrapper.h>

#include"test/test_tools.h"

#include"test/graph_test.h"

/**

\file

This test makes consistency checks of list graph structures.

G.addNode(), G.addEdge(), G.tail(), G.head()

\todo Checks for empty graphs and isolated points.

conversion.

*/

using namespace hugo;

// template<class Graph> void bidirPetersen(Graph &G)

// {

//   typedef typename Graph::Edge Edge;

//   typedef typename Graph::EdgeIt EdgeIt;

//   checkGraphEdgeList(G,15);

//   std::vector<Edge> ee;

//   for(EdgeIt e(G);e!=INVALID;++e) ee.push_back(e);

//   for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)

//     G.addEdge(G.head(*p),G.tail(*p));

// }

// template<class Graph> void checkPetersen(Graph &G)

// {

//   typedef typename Graph::Node Node;

//   typedef typename Graph::EdgeIt EdgeIt;

//   typedef typename Graph::NodeIt NodeIt;

//   checkGraphNodeList(G,10);

//   checkGraphEdgeList(G,30);

//   for(NodeIt n(G);n!=INVALID;++n) {

//     checkGraphInEdgeList(G,n,3);

//     checkGraphOutEdgeList(G,n,3);

//     ++n;

//   }  

// }

// //Compile GraphSkeleton

// template void checkCompileStaticGraph<skeleton::StaticGraphSkeleton>

// (skeleton::StaticGraphSkeleton &);

// template void checkCompileGraph<skeleton::ExtendableGraphSkeleton>

// (skeleton::ExtendableGraphSkeleton &);

// template void checkCompileErasableGraph<skeleton::ErasableGraphSkeleton>

// (skeleton::ErasableGraphSkeleton &);

//Compile SmartGraph

typedef SmartGraph Graph;

typedef GraphWrapper<Graph> GW;

template void checkCompileStaticGraph<GW>(GW &);

//template void checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);

//Compile SymSmartGraph

typedef RevGraphWrapper<Graph> RevGW;

template void checkCompileStaticGraph<RevGW>(RevGW &);

//template void checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);

// //Compile ListGraph

// template void checkCompileGraph<ListGraph>(ListGraph &);

// template void checkCompileErasableGraph<ListGraph>(ListGraph &);

// template void checkCompileGraphFindEdge<ListGraph>(ListGraph &);

// //Compile SymListGraph

// template void checkCompileGraph<SymListGraph>(SymListGraph &);

// template void checkCompileErasableGraph<SymListGraph>(SymListGraph &);

// template void checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);

// //Compile FullGraph

// template void checkCompileStaticGraph<FullGraph>(FullGraph &);

// template void checkCompileGraphFindEdge<FullGraph>(FullGraph &);

// //Compile EdgeSet <ListGraph>

// template void checkCompileGraph<EdgeSet <ListGraph> >(EdgeSet <ListGraph> &);

// template void checkCompileGraphEraseEdge<EdgeSet <ListGraph> >

// (EdgeSet <ListGraph> &);

// template void checkCompileGraphFindEdge<EdgeSet <ListGraph> >

// (EdgeSet <ListGraph> &);

// //Compile EdgeSet <NodeSet>

// template void checkCompileGraph<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);

// template void checkCompileGraphEraseEdge<EdgeSet <NodeSet> >

// (EdgeSet <NodeSet> &);

// template void checkCompileGraphFindEdge<EdgeSet <NodeSet> >

// (EdgeSet <NodeSet> &);

int main() 

{

 //  {

//     SmartGraph G;

//     addPetersen(G);

//     bidirPetersen(G);

//     checkPetersen(G);

//   }

//   {

//     ListGraph G;

//     addPetersen(G);

//     bidirPetersen(G);

//     checkPetersen(G);

//   }

//   {

//     SymSmartGraph G;

//     addPetersen(G);

//     checkPetersen(G);

//   }

//   {

//     SymListGraph G;

//     addPetersen(G);

//     checkPetersen(G);

//   }

  ///\file

  ///\todo map tests.

  ///\todo copy constr tests.

  std::cout << __FILE__ ": All tests passed.\n";

  return 0;

}