/* -*- C++ -*-

 * src/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;

}