/* -*- C++ -*-

  * test/graph_test.cc - Part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2005 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/smart_graph.h>

 #include<lemon/concept/graph.h>

 #include<lemon/concept/maps.h>

 #include<lemon/list_graph_base.h>

 #include<lemon/full_graph.h>

 #include"test_tools.h"

 #include"graph_test.h"

 /**

 \file

 This test makes consistency checks of list graph structures.

 G.addNode(), G.addEdge(), G.source(), G.target()

 \todo Checks for empty graphs and isolated points.

 conversion.

 */

 using namespace lemon;

 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.target(*p),G.source(*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);

   }  

 }

 //Compile Graph

 template void lemon::concept::checkCompileStaticGraph<concept::StaticGraph>

 (concept::StaticGraph &);

 template

 void lemon::concept::checkCompileExtendableGraph<concept::ExtendableGraph>

 (concept::ExtendableGraph &);

 template

 void lemon::concept::checkCompileErasableGraph<concept::ErasableGraph>

 (concept::ErasableGraph &);

 //Compile SmartGraph

 template

 void lemon::concept::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);

 template

 void lemon::concept::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);

 //Compile SymSmartGraph

 //template void hugo::checkCompileGraph<SymSmartGraph>(SymSmartGraph &);

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

 //Compile ListGraph

 template

 void lemon::concept::checkCompileExtendableGraph<ListGraph>(ListGraph &);

 template

 void lemon::concept::checkCompileErasableGraph<ListGraph>(ListGraph &);

 template

 void lemon::concept::checkCompileGraphFindEdge<ListGraph>(ListGraph &);

 //Compile SymListGraph

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

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

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

 //Compile FullGraph

 template void lemon::concept::checkCompileStaticGraph<FullGraph>(FullGraph &);

 template

 void lemon::concept::checkCompileGraphFindEdge<FullGraph>(FullGraph &);

 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.

   // Some map tests.

   // FIXME: These shouldn't be here.

   using namespace concept;

   function_requires< ReadMapConcept< ReadMap<int,int> > >();

   function_requires< WriteMapConcept< WriteMap<int,int> > >();

   function_requires< ReadWriteMapConcept< ReadWriteMap<int,int> > >();

   function_requires< ReferenceMapConcept< ReferenceMap<int,int> > >();

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

   return 0;

 }