source: lemon-0.x/src/test/graph_factory_test.cc @ 1416:1b481ced25e7

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