COIN-OR::LEMON - Graph Library

Changeset 946:c94ef40a22ce in lemon-0.x for src/test/graph_test.cc


Ignore:
Timestamp:
10/28/04 00:38:50 (17 years ago)
Author:
Mihaly Barasz
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1322
Message:

The graph_factory branch (@ 1321) has been merged to trunk.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/test/graph_test.cc

    r938 r946  
    1 /* -*- C++ -*-
    2  * src/test/graph_test.cc - Part of LEMON, a generic C++ optimization library
    3  *
    4  * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    5  * (Egervary Combinatorial Optimization Research Group, EGRES).
    6  *
    7  * Permission to use, modify and distribute this software is granted
    8  * provided that this copyright notice appears in all copies. For
    9  * precise terms see the accompanying LICENSE file.
    10  *
    11  * This software is provided "AS IS" with no warranty of any kind,
    12  * express or implied, and with no claim as to its suitability for any
    13  * purpose.
    14  *
    15  */
     1// -*- c++ -*-
    162
    17 #include<iostream>
    18 #include<lemon/smart_graph.h>
    19 #include<lemon/skeletons/graph.h>
    20 #include<lemon/list_graph.h>
    21 #include<lemon/full_graph.h>
     3#include <iostream>
     4#include <vector>
    225
    23 #include"test_tools.h"
    24 #include"graph_test.h"
     6#include <lemon/skeletons/graph.h>
     7#include <lemon/list_graph.h>
     8#include <lemon/smart_graph.h>
     9#include <lemon/full_graph.h>
    2510
    26 /**
    27 \file
    28 This test makes consistency checks of list graph structures.
     11#include "test_tools.h"
     12#include "graph_test.h"
     13#include "map_test.h"
    2914
    30 G.addNode(), G.addEdge(), G.tail(), G.head()
    31 
    32 \todo Checks for empty graphs and isolated points.
    33 conversion.
    34 */
    3515
    3616using namespace lemon;
    37 
    38 template<class Graph> void bidirPetersen(Graph &G)
    39 {
    40   typedef typename Graph::Edge Edge;
    41   typedef typename Graph::EdgeIt EdgeIt;
    42  
    43   checkGraphEdgeList(G,15);
    44  
    45   std::vector<Edge> ee;
    46  
    47   for(EdgeIt e(G);e!=INVALID;++e) ee.push_back(e);
    48 
    49   for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)
    50     G.addEdge(G.head(*p),G.tail(*p));
    51 }
    52 
    53 template<class Graph> void checkPetersen(Graph &G)
    54 {
    55   typedef typename Graph::Node Node;
    56 
    57   typedef typename Graph::EdgeIt EdgeIt;
    58   typedef typename Graph::NodeIt NodeIt;
    59 
    60   checkGraphNodeList(G,10);
    61   checkGraphEdgeList(G,30);
    62 
    63   for(NodeIt n(G);n!=INVALID;++n) {
    64     checkGraphInEdgeList(G,n,3);
    65     checkGraphOutEdgeList(G,n,3);
    66   } 
    67 }
    68 
    69 //Compile Graph
    70 template void lemon::skeleton::checkCompileStaticGraph<skeleton::StaticGraph>
    71 (skeleton::StaticGraph &);
    72 
    73 template
    74 void lemon::skeleton::checkCompileExtendableGraph<skeleton::ExtendableGraph>
    75 (skeleton::ExtendableGraph &);
    76 
    77 template
    78 void lemon::skeleton::checkCompileErasableGraph<skeleton::ErasableGraph>
    79 (skeleton::ErasableGraph &);
    80 
    81 //Compile SmartGraph
    82 template
    83 void lemon::skeleton::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);
    84 template
    85 void lemon::skeleton::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
    86 
    87 //Compile SymSmartGraph
    88 //template void hugo::checkCompileGraph<SymSmartGraph>(SymSmartGraph &);
    89 //template void hugo::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
    90 
    91 //Compile ListGraph
    92 template
    93 void lemon::skeleton::checkCompileExtendableGraph<ListGraph>(ListGraph &);
    94 template
    95 void lemon::skeleton::checkCompileErasableGraph<ListGraph>(ListGraph &);
    96 template
    97 void lemon::skeleton::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
     17using namespace lemon::skeleton;
    9818
    9919
    100 //Compile SymListGraph
    101 //template void hugo::checkCompileGraph<SymListGraph>(SymListGraph &);
    102 //template void hugo::checkCompileErasableGraph<SymListGraph>(SymListGraph &);
    103 //template void hugo::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
     20int main() {
     21  ///\file
     22  { // checking graph components
     23    function_requires<BaseGraphComponentConcept<BaseGraphComponent> >();
    10424
    105 //Compile FullGraph
    106 template void lemon::skeleton::checkCompileStaticGraph<FullGraph>(FullGraph &);
    107 template
    108 void lemon::skeleton::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
     25    function_requires<BaseIterableGraphComponentConcept<BaseIterableGraphComponent> >();
    10926
    110 //Compile EdgeSet <ListGraph>
    111 template void lemon::skeleton::checkCompileExtendableGraph<EdgeSet <ListGraph> >
    112 (EdgeSet <ListGraph> &);
    113 template void lemon::skeleton::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
    114 (EdgeSet <ListGraph> &);
    115 template void lemon::skeleton::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
    116 (EdgeSet <ListGraph> &);
     27    function_requires<IDableGraphComponentConcept<IDableGraphComponent> >();
     28    function_requires<MaxIDableGraphComponentConcept<MaxIDableGraphComponent> >();
    11729
    118 //Compile EdgeSet <NodeSet>
    119 template void lemon::skeleton::checkCompileExtendableGraph<EdgeSet <NodeSet> >
    120 (EdgeSet <NodeSet> &);
    121 template void lemon::skeleton::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
    122 (EdgeSet <NodeSet> &);
    123 template void lemon::skeleton::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
    124 (EdgeSet <NodeSet> &);
     30    function_requires<BaseExtendableGraphComponentConcept<BaseExtendableGraphComponent> >();
     31    function_requires<BaseErasableGraphComponentConcept<BaseErasableGraphComponent> >();
     32    function_requires<BaseClearableGraphComponentConcept<BaseClearableGraphComponent> >();
    12533
     34    function_requires<IterableGraphComponentConcept<IterableGraphComponent> >();
    12635
    127 int main()
    128 {
    129   {
    130     SmartGraph G;
    131     addPetersen(G);
    132     bidirPetersen(G);
    133     checkPetersen(G);
     36    function_requires<IdMappableGraphComponentConcept<IdMappableGraphComponent> >();
     37    function_requires<MappableGraphComponentConcept<MappableGraphComponent> >();
     38
     39    function_requires<ExtendableGraphComponentConcept<ExtendableGraphComponent> >();
     40    function_requires<ErasableGraphComponentConcept<ErasableGraphComponent> >();
     41    function_requires<ClearableGraphComponentConcept<ClearableGraphComponent> >();
    13442  }
    135   {
    136     ListGraph G;
    137     addPetersen(G);
    138     bidirPetersen(G);
    139     checkPetersen(G);
     43  { // checking skeleton graphs
     44    function_requires<StaticGraphConcept<StaticGraph> >();
     45    function_requires<ExtendableGraphConcept<ExtendableGraph> >();
     46    function_requires<ErasableGraphConcept<ErasableGraph> >();
    14047  }
    141   {
    142     //    SymSmartGraph G;
    143     //    addPetersen(G);
    144     //    checkPetersen(G);
     48  { // checking list graph
     49    function_requires<ErasableGraphConcept<ListGraph> >();
     50
     51    checkGraph<ListGraph>();
     52    checkGraphNodeMap<ListGraph>();
     53    checkGraphEdgeMap<ListGraph>();
    14554  }
    146   {
    147     //    SymListGraph G;
    148     //    addPetersen(G);
    149     //    checkPetersen(G);
     55  { // checking smart graph
     56    function_requires<ExtendableGraphConcept<SmartGraph> >();
     57
     58    checkGraph<SmartGraph>();
     59    checkGraphNodeMap<SmartGraph>();
     60    checkGraphEdgeMap<SmartGraph>();
    15061  }
    151 
    152   ///\file
    153   ///\todo map tests.
    154   ///\todo copy constr tests.
     62  { // checking full graph
     63    function_requires<StaticGraphConcept<FullGraph> >();
     64  }
    15565
    15666  std::cout << __FILE__ ": All tests passed.\n";
Note: See TracChangeset for help on using the changeset viewer.