Clase ADH_Graph:: test_Graph.cpp Source File

00001 // test_Graph.cpp (c) [email protected]
00002 
00003 /** \file  test_Graph.cpp
00004     \brief Datos de prueba para la clase \c ADH_Graph.
00005 
00006     \author Adolfo Di Mare <[email protected]>
00007     \date   2007
00008 */
00009 
00010 #include "ADH_test.h"
00011 #include "ADH_Graph.h"
00012 
00013 namespace ADH {
00014 
00015 /// Clase simple para probar la clase \c ADH_Graph.
00016 class test_Graph : public TestCase {
00017     Graph G;  ///< Valor usado en las pruebas.
00018 public:
00019     test_Graph() : G() {} ///< Constructor por defecto.
00020     void test_connected();
00021     void test_isVertex();
00022     void setUp();
00023     void do_cout( std::ostream & COUT );
00024     void do_dump( std::ostream & COUT );
00025     void test_const_iterator();
00026     bool run();
00027 }; // test_Graph
00028 
00029 /// Ejecuta las pruebas para \c test_Graph.
00030 bool test_Graph::run() {
00031     test_connected();
00032     test_isVertex();
00033     test_const_iterator();
00034     return wasSuccessful();
00035 }
00036 
00037 /*
00038     {{ // test::diagram()
00039          A(1)         C(1)        O(1)---->O(2)
00040         /    \       /    \       /|\       |
00041        /      \     /      \       |        |
00042     F----A(2)----B--        --D    |        |
00043        \      /     \      /       |        |
00044         \    /       \    /        |       \|/
00045          A(3)         C(2)        O(4)<----O(3)
00046     }}
00047 */
00048 void test_Graph::setUp() {
00049     G.set("F", "A(1)",  2 ); G.set( "A(1)", "B",  2 );
00050     G.set("F", "A(2)",  8 ); G.set( "A(2)", "B",  8 );
00051     G.set("F", "A(3)", 64 ); G.set( "A(3)", "B", 64 );
00052 
00053     G.set("B", "C(1)",  3 ); G.set( "C(1)", "D",  3 );
00054     G.set("B", "C(2)", 27 ); G.set( "C(2)", "D", 27 );
00055 
00056     G.set("O(1)", "O(2)", 2*2*2 );
00057     G.set("O(2)", "O(3)", 3*3*3 );
00058     G.set("O(3)", "O(4)", 5*5*5 );
00059     G.set("O(4)", "O(1)", 7*7*7 );
00060 }
00061 
00062 /// Graba en \c COUT el valor de \c G (Fixture).
00063 void test_Graph::do_cout( std::ostream & COUT ) {
00064     COUT << G;
00065 }
00066 
00067 /// Graba en \c COUT el valor de \c G (Fixture).
00068 void test_Graph::do_dump( std::ostream & COUT ) {
00069     Graph G;
00070     G.set("O(1)", "O(2)", 2*2*2 );
00071     G.set("O(2)", "O(3)", 3*3*3 );
00072     G.set("O(3)", "O(4)", 5*5*5 );
00073     G.set("O(4)", "O(1)", 7*7*7 );
00074     ADH::dump( COUT , G );
00075 }
00076 
00077 /// Prueba \c Graph::const_iterator().
00078 void test_Graph::test_const_iterator() {
00079     {{ // test::const_iterator()
00080         Graph Tree;
00081         Tree.set("root", "child(1)", 1 );
00082         Tree.set("root", "child(2)", 2*2 );
00083         Tree.set("root", "child(3)", 3*3*3);
00084         Graph::const_iterator it, jt; int val = int();
00085         for ( it = Tree.begin() ; it != Tree.end() ; ++it ) {
00086             for ( jt = Tree.begin() ; jt != Tree.end() ; ++jt ) {
00087                 if ( Tree.isArc( it->first , jt->first , val ) ) {
00088                     assertTrue( it->first == "root" );
00089                     assertTrue( jt->first.substr(0,5) == "child" );
00090                 }
00091             }
00092         }
00093     }}
00094 }
00095 
00096 /// Prueba \c Graph::connected().
00097 void test_Graph::test_connected() {
00098     {{ // test::connected()
00099         std::list< std::string > C; // camino en el grafo
00100         std::list< std::string >::iterator it;
00101 
00102         assertTrue( G.connected(  "F" ,  "C(1)", C ) ); // grafo no conexo
00103                 assertTrue( ! G.connected( "???" , "???",  C ) ); // no existe el vértice
00104         assertTrue( ! G.connected(  "F" ,  "O(4)", C ) ); // grafo no conexo
00105         assertTrue( C.size() == 0);
00106         assertTrue( ! G.connected( "D" , "F"   , C ) ); // el grafo es dirigido
00107         assertTrue( C.size() == 0);
00108 
00109         assertTrue( G.connected( "F" , "F", C ) );       // si está conectado
00110         assertTrue( C.size() == 1 && C.front() == "F" ); // porque ya está ahí
00111 
00112         assertTrue( ! G.connected( "D", "A(2)" , C ) ); assertTrue( C.size() == 0 );
00113         assertTrue( G.connected( "A(2)" , "D", C ) );   assertTrue( C.size() == 4 );
00114         assertTrue( C.front() == "A(2)" && C.back() == "D" );
00115         it = C.begin(); it++;
00116         assertTrue( *it == "B" ); // 2do nodo en el camino
00117         it++;
00118         assertTrue( *it == "C(1)" || *it == "C(2)" ); // 3er nodo en el camino
00119     }}
00120     {  // resto de las pruebas
00121         std::list< std::string > C,L;
00122         std::list< std::string >::iterator it;
00123         assertTrue( ! G.connected( "D", "F" , C ) ); assertTrue( C.size() == 0 );
00124         assertTrue(   G.connected( "F", "D" , C ) ); assertTrue( C.size() == 5 );
00125         assertTrue( C.front() == "F" && C.back() == "D" );
00126         it = C.begin();
00127         assertTrue( *it == "F" ); // 1ero nodo en el camino
00128         it++;
00129         assertTrue( *it == "A(1)" || *it == "A(2)" || *it == "A(3)" ); // 2do nodo
00130         it++;
00131         assertTrue( *it == "B" ); // 3er nodo
00132         it++;
00133         assertTrue( *it == "C(1)" || *it == "C(2)" ); // 4to nodo
00134         it++;
00135         assertTrue( *it == "D" ); // 5to nodo
00136     }
00137     {
00138         ADH::Graph G;
00139         G.set( "1", "2", 2 ); {          //         1         //
00140             G.set( "2", "4", 4 );  {     //        / \        //
00141                 G.set( "4", "8", 8 );    //       /   \       //
00142                 G.set( "4", "9", 9 );    //     2       3     //
00143             }                            //    / \     / \    //
00144             G.set( "2", "5", 5 );  {     //    4 5     6 7    //
00145                 G.set( "5", "10", 10 );  //   /\ /\   /\ /\   //
00146                 G.set( "5", "11", 11 );  //   89 AB   CD EF   //
00147             }
00148         }
00149         G.set( "1", "3", 3 );  {
00150             G.set( "3", "6", 6 );  {
00151                 G.set( "6", "12", 12 );
00152                 G.set( "6", "13", 13 );
00153             }
00154             G.set( "3", "7", 7 );  {
00155                 G.set( "7", "14", 14 );
00156                 G.set( "7", "15", 15 );
00157             }
00158         }
00159         using namespace std;
00160         list< string > C; int val, i, j, k, n;
00161         for ( i=2; i<16; ++i ) {
00162             string i_str = TestCase::toString(i);
00163             for ( j=2; j<16; ++j ) {
00164                 val = 666; C.clear(); C.push_back( "???" );
00165                 string j_str = TestCase::toString(j), k_str;
00166                 if ( i==j ) {
00167                     assertTrue( ! G.isArc    ( i_str , j_str, val ) );
00168                     assertTrue( val == 666 && "unchanged val" );
00169                     assertTrue(   G.connected( i_str , j_str, C ) );
00170                     assertTrue( C.size() >= 1 && C.front() == i_str );
00171                     assertTrue( ! G.connected( i_str , "1",   C   ) );
00172                     assertTrue( C.empty() );
00173                     assertTrue(   G.connected(  "1"  , i_str , C  ) );
00174                     assertTrue( C.size() >= 1 && C.front() == i_str );
00175                 }
00176                 else if ( i < j ) {
00177                     for ( (n=1, k=j); k>0 ; (k/=2,++n) ) {
00178                         k_str = TestCase::toString(k);
00179                         assertTrue( G.connected(  k_str , j_str , C  ) );
00180                         assertTrue( C.front() == k_str && C.back() == j_str );
00181                         assertTrue( C.size()  == n );
00182                         assertTrue( ! G.connected(  j_str , k_str , C  ) );
00183                         assertTrue( C.empty() );
00184                     }
00185                 }
00186             }
00187         }
00188     }
00189 }
00190 
00191 /// Prueba \c Graph::isVertex()
00192 void test_Graph::test_isVertex() {
00193     {{ // test::isVertex()
00194         Graph G; int val = 666;
00195         G.set( "F", "D", 2*2*2 );
00196         assertTrue( G.isVertex( "F" ) ) ;
00197         assertTrue( G.isVertex( "D" ) ) ;
00198         assertTrue( val == 666 && "initial val" );
00199         assertTrue( G.isArc( "F" , "D", val ) );
00200         assertTrue( val == 2*2*2 && "returned val" );
00201         val = 666;
00202         assertTrue( ! G.isArc( "D" , "F", val ) );
00203         assertTrue( val == 666 && "unchanged val" );
00204     }}
00205     {   Graph::Rep::const_iterator it = G.m_DICC.begin();
00206         for ( ; it != G.m_DICC.end(); ++it ) {
00207             assertTrue(   G.isVertex( it->first ) ) ;
00208             assertTrue( ! G.isVertex( it->first + "chungis") ) ;
00209         }
00210     }
00211     {   int val;
00212         Graph::Rep::const_iterator it = G.m_DICC.begin();  // recorre m_DICC[]
00213         for ( ; it != G.m_DICC.begin(); ++it ) {
00214             Graph::mapped_type::const_iterator jt = it->second.begin();
00215             for ( ; jt != it->second.end(); ++jt ) {
00216                 assertTrue( G.isArc( it->first , jt->first , val ) );
00217                 assertTrue( val == jt->second );
00218                 assertTrue( ! G.isArc( 'c'+it->first ,     jt->first , val ) );
00219                 assertTrue( ! G.isArc( 'c'+it->first , 'c'+jt->first , val ) );
00220                 assertTrue( ! G.isArc(     it->first , 'c'+jt->first , val ) );
00221             }
00222         }
00223         assertTrue( ! G.isArc( "A(1)" , "O(1)" ,  val ) );
00224         assertTrue( ! G.isArc( "O(1)" , "A(1)" ,  val ) );
00225         assertTrue( ! G.isArc( "O(4)" , "O(3)" ,  val ) );
00226         assertTrue( ! G.isArc( "0(1)" ,  "B"   ,  val ) );
00227         assertTrue( ! G.isArc( "A(3)" ,  "F"   ,  val ) );
00228     }
00229 }
00230 
00231 } // namespace ADH
00232 
00233 
00234 /// Programa principal para probar la clase \c ADH_Graph.
00235 int main() {
00236     using namespace ADH;
00237     using namespace std;
00238     test_Graph test_Graph_Instance;
00239     test_Graph_Instance.setUp();
00240     if (1) {
00241         test_Graph_Instance.do_dump(cout); cout << endl;
00242         test_Graph_Instance.do_cout(cout); cout << endl;
00243     }
00244     test_Graph_Instance.run();
00245     cout << test_Graph_Instance.report() << endl;
00246 }
00247 // EOF: test_Graph.cpp