lkptr<X> - simple reference LinKed PoinTeR:: test

00001 // test_lkptr.cpp (C) 2007 adolfo@di-mare.com
00002 
00003 /** \file  test_lkptr.cpp
00004     \brief Test data for class \c lkptr<X>.
00005 
00006     \author Adolfo Di Mare <adolfo@di-mare.com>
00007     \date   2008.
00008 */
00009 
00010 #include "lkptr.h"
00011 #include "BUnit.h" // Módulo para prueba unitaria de programas
00012 
00013 /// Test data for class \c lkptr.
00014 template <class X>
00015 class test_lkptr : public TestCase {
00016 public:
00017     bool run();
00018     void swap_4x1();
00019     void verify_3x1();
00020     void null_3x1();
00021     void inheritance();
00022     void test_lkptr_cycle();
00023 };
00024 
00025 /// Runs the tests.
00026 template <class X>
00027 bool test_lkptr<X>::run() {
00028     verify_3x1();
00029     swap_4x1();
00030     null_3x1();
00031     inheritance();
00032     test_lkptr_cycle();
00033 
00034     return wasSuccessful();
00035 }
00036 
00037 /// Tries with 3 pointes to the same value.
00038 template <class X>
00039 void test_lkptr<X>::null_3x1() {
00040     lkptr<X> A, B, C;
00041     A = B = C;
00042     assertTrue( A.ok() );   assertTrue( check_ok(A) );
00043     assertTrue( B.ok() );   assertTrue( check_ok(C) );
00044     assertTrue( C.ok() );   assertTrue( check_ok(C) );
00045 
00046     assertTrue( A.use_count() == 3 );
00047     assertTrue( B.use_count() == 3 );
00048     assertTrue( C.use_count() == 3 );
00049 
00050     assertTrue( A == B );
00051     assertTrue( B == C );
00052     assertTrue( A == 0 );
00053 
00054     assertTrue( A.use_count() == 3 );
00055     assertTrue( B.use_count() == 3 );
00056     assertTrue( C.use_count() == 3 );
00057 }
00058 
00059 /// Swaps 4 \c lkptr<X>'s.
00060 template <class X>
00061 void test_lkptr<X>::swap_4x1() {
00062     X* p = new X();
00063     lkptr<X> A ( p );
00064     lkptr<X> B, C, D;
00065 
00066     assertTrue( A.use_count() == 1 );
00067     assertTrue( B.use_count() == 1 );
00068     assertTrue( C.use_count() == 1 );
00069     assertTrue( A.get() != 0 && *A == *p);
00070     A.swap(A); B.swap(B);
00071     A.swap(B); // *B==*p && A==null && C==null
00072     assertTrue( A.get() == 0 );
00073     assertTrue( B.get() != 0 && *B == *p);
00074     assertTrue( C.get() == 0 );
00075     assertTrue( A.use_count() == 1 );
00076     assertTrue( B.use_count() == 1 );
00077     assertTrue( C.use_count() == 1 );
00078     C.swap(C); B.swap(B);
00079     C.swap(B); // *C==*p && A==null && B==null
00080     assertTrue( A.get() == 0 );
00081     assertTrue( B.get() == 0 );
00082     assertTrue( C.get() != 0 && *C == *p);
00083 
00084     A = B; // *C==0 && (A==B==null)
00085     assertTrue( A.use_count() == 2 );
00086     assertTrue( B.use_count() == 2 );
00087     assertTrue( C.use_count() == 1 );
00088 
00089     B.swap(B); C.swap(C);
00090     B.swap(C); // *B==0 && (A==C==null)
00091     assertTrue( A.use_count() == 2 );
00092     assertTrue( B.use_count() == 1 );
00093     assertTrue( C.use_count() == 2 );
00094 
00095     assertTrue( A.get() == 0 );
00096     assertTrue( B.get() != 0 && *B == X());
00097     assertTrue( C.get() == 0 );
00098 
00099     C = B; // A==null && (B==C==p) != null
00100     assertTrue( A.use_count() == 1 );
00101     assertTrue( B.use_count() == 2 );
00102     assertTrue( C.use_count() == 2 );
00103     assertTrue( A.get() == 0 );
00104     assertTrue( B.get() != 0 && *B == X());
00105     assertTrue( C.get() != 0 && *C == X());
00106 
00107     C.swap(B); // A==null && (B==C==p) != null
00108     assertTrue( B.use_count() == 2 );
00109     assertTrue( C.use_count() == 2 );
00110     assertTrue( B.get() != 0 && *B == X());
00111     assertTrue( C.get() != 0 && *C == X());
00112 
00113     X* q = new X();
00114     C.reset( q ); // A==null && (B==p) != (C==q)
00115     assertTrue( A.use_count() == 1 );
00116     assertTrue( B.use_count() == 1 );
00117     assertTrue( C.use_count() == 1 );
00118     assertTrue( B.get() != 0 && *B == X());
00119     assertTrue( C.get() != 0 && *C == X());
00120     assertTrue( B.get() != C.get() );
00121 
00122     A=B; D=C;  // (A===B==p) != (C==D==q)
00123     assertTrue(  A.use_count() == 2 );
00124     assertTrue(  B.use_count() == 2 );
00125     assertTrue(  C.use_count() == 2 );
00126     assertTrue(  D.use_count() == 2 );
00127     assertTrue(  A.get() == B.get() );
00128     assertTrue(  C.get() == D.get() );
00129     assertTrue(  A.get() != C.get() );
00130     assertTrue( *A == *p && *C == *q );
00131 
00132     A.swap(B); D.swap(C);  // (A===B==p) != (C==D==q)
00133     assertTrue(  A.get() == B.get() );
00134     assertTrue(  C.get() == D.get() );
00135     assertTrue(  A.get() != C.get() );
00136     assertTrue(  A.get() == p && C.get() == q );
00137 
00138     A.swap(C); // (C===B==p) != (A==D==q)
00139     assertTrue(  C.get() == B.get() );
00140     assertTrue(  A.get() == D.get() );
00141     assertTrue(  A.get() != C.get() );
00142     assertTrue(  A.use_count() == 2 );
00143     assertTrue(  B.use_count() == 2 );
00144     assertTrue(  C.use_count() == 2 );
00145     assertTrue(  D.use_count() == 2 );
00146     assertTrue( *A == *q && *C == *p );
00147 
00148     A = B; // (A==C===B==p) != (D==q)
00149     assertTrue(  A.use_count() == 3 );
00150     assertTrue(  B.use_count() == 3 );
00151     assertTrue(  C.use_count() == 3 );
00152     assertTrue(  D.use_count() == 1 );
00153     assertTrue(  A.get() == B.get() );
00154     assertTrue(  B.get() == C.get() );
00155     assertTrue(  A.get() != D.get() );
00156     assertTrue(  A.get() == p && D.get() == q );
00157     assertTrue( *A == *p && *D == *q );
00158 
00159     D = C; // (A==C===B==D==p) && (q->bye->bye)
00160     assertTrue(  A.use_count() == 4 );
00161     assertTrue(  B.use_count() == 4 );
00162     assertTrue(  C.use_count() == 4 );
00163     assertTrue(  D.use_count() == 4 );
00164     assertTrue(  A.get() == B.get() );
00165     assertTrue(  B.get() == C.get() );
00166     assertTrue(  C.get() == D.get() );
00167     assertTrue(  A.get() == p && A.get() != q );
00168 
00169     A.swap(B); B.swap(C);
00170     C.swap(D); D.swap(A);
00171     A.swap(A); B.swap(B); C.swap(C); D.swap(D);
00172     assertTrue(  A.use_count() == 4 );
00173     assertTrue(  B.use_count() == 4 );
00174     assertTrue(  C.use_count() == 4 );
00175     assertTrue(  D.use_count() == 4 );
00176     assertTrue(  A.get() == B.get() );
00177     assertTrue(  B.get() == C.get() );
00178     assertTrue(  C.get() == D.get() );
00179     assertTrue(  A.get() == p && A.get() != q );
00180 
00181     D.release(); // (A==C===B==p) && (D==0)
00182     assertTrue(  A.use_count() == 3 );
00183     assertTrue(  B.use_count() == 3 );
00184     assertTrue(  C.use_count() == 3 );
00185     assertTrue(  D.use_count() == 1 );
00186     assertTrue(  A.get() == B.get() );
00187     assertTrue(  B.get() == C.get() );
00188     assertTrue(  C.get() != D.get() );
00189     assertTrue(  A.get() == p && A.get() != q );
00190     assertTrue(  D.get() == 0 );
00191 
00192     D = A; // (A==C==B==D==p)
00193     A.swap(A); B.swap(B); C.swap(C); D.swap(D);
00194     assertTrue(  A.use_count() == 4 );
00195     assertTrue(  B.use_count() == 4 );
00196     assertTrue(  C.use_count() == 4 );
00197     assertTrue(  D.use_count() == 4 );
00198     assertTrue(  A.get() == B.get() );
00199     assertTrue(  B.get() == C.get() );
00200     assertTrue(  C.get() == D.get() );
00201     assertTrue(  A.get() == p && A.get() != q );
00202 
00203     D.release();  // (A==C==B==p) && (D==0)
00204     D.swap(A);    // (D==C==B==p) && (A==0)
00205     assertTrue(  A.use_count() == 1 );
00206     assertTrue(  B.use_count() == 3 );
00207     assertTrue(  C.use_count() == 3 );
00208     assertTrue(  D.use_count() == 3 );
00209     assertTrue(  A.get() != B.get() );
00210     assertTrue(  B.get() == C.get() );
00211     assertTrue(  C.get() == D.get() );
00212     assertTrue(  D.get() == p && D.get() != q );
00213     assertTrue(  A.get() == 0 );
00214 
00215     C.release();  // (D==B==p) && (A==0) && (C==0)
00216     assertTrue( A.isNull() && C.isNull() );
00217     assertTrue(  A.get() == C.get() );
00218     assertTrue(  B.get() == D.get() );
00219     assertTrue(  A.use_count() == 1 );
00220     assertTrue(  B.use_count() == 2 );
00221     assertTrue(  C.use_count() == 1 );
00222     assertTrue(  D.use_count() == 2 );
00223     D.swap(D); B.swap(B);
00224 
00225     C.swap(B);  // (C==D==p) && (A==0) && (B==0)
00226     assertTrue( A.isNull() && B.isNull() );
00227     assertTrue(  A.get() == B.get() );
00228     assertTrue(  C.get() == D.get() );
00229     assertTrue(  A.use_count() == 1 );
00230     assertTrue(  B.use_count() == 1 );
00231     assertTrue(  C.use_count() == 2 );
00232     assertTrue(  D.use_count() == 2 );
00233     D.swap(D); C.swap(C); A.swap(A); C.swap(D);
00234 
00235     B = C;  // (B==C==D==p) && (A==0)
00236     assertTrue(  A.use_count() == 1 );
00237     assertTrue(  B.use_count() == 3 );
00238     assertTrue(  C.use_count() == 3 );
00239     assertTrue(  D.use_count() == 3 );
00240     assertTrue(  B.get() == C.get() );
00241     assertTrue(  C.get() == D.get() );
00242 
00243     A.swap(B); // (A==C==D==p) && (B==0)
00244     assertTrue(  A.use_count() == 3 );
00245     assertTrue(  B.use_count() == 1 );
00246     assertTrue(  C.use_count() == 3 );
00247     assertTrue(  D.use_count() == 3 );
00248     assertTrue(  A.get() == C.get() );
00249     assertTrue(  C.get() == D.get() );
00250     assertTrue(  B.isNull() );
00251 }
00252 
00253 /// Tries with 3 pointes to the same value.
00254 template <class X>
00255 void test_lkptr<X>::verify_3x1() {
00256     lkptr<X> A ( new X() ); // A = new X(); won't compile ("explicit" constructor)
00257     lkptr<X> B, C;
00258     B = A; // B.operator=( A );
00259     C = B;
00260 
00261     assertTrue( A.ok() );   assertTrue( check_ok(A) );
00262     assertTrue( B.ok() );   assertTrue( check_ok(C) );
00263     assertTrue( C.ok() );   assertTrue( check_ok(C) );
00264 
00265     assertTrue( A.use_count() == 3 );
00266     assertTrue( B.use_count() == 3 );
00267     assertTrue( C.use_count() == 3 );
00268 
00269     assertTrue( A.get() == B.get() );
00270     assertTrue( A == B );
00271     assertTrue( B == C );
00272     assertTrue( A == C.get() );
00273     assertTrue( A.get() == C );
00274 
00275     A.release();
00276     assertTrue( A.use_count() == 1 );
00277     assertTrue( B.use_count() == 2 );
00278     assertTrue( C.use_count() == 2 );
00279     assertTrue( B.get() == C.get() );
00280     assertTrue( A != C );
00281 
00282     assertTrue( A.get() == 0 );
00283 
00284     B.release();
00285     assertTrue( A.get() == B.get() );
00286     assertTrue( C.get() != 0 );
00287 }
00288 
00289 // AutoRef::Auto-Referencia
00290 struct AutoRef {
00291     static     int m_cont;  ///< Cantidad total de objetos
00292     lkptr<AutoRef> m_otro;  ///< Enlace circular a otro objeto
00293     AutoRef() { m_cont++; } ///< Constructor (aumenta cuenta de objetos)
00294     ~AutoRef() {
00295         m_cont--;
00296         #ifndef AutoRef_BOOOOMMMM
00297             m_otro.weak_release();
00298         #endif
00299     } ///< Destructor (libera \c lkptr<>)
00300     void set( AutoRef * ptr ) { m_otro.reset( ptr ); } ///< Entrelaza a \c ptr.
00301     static int cont() { return m_cont; } ///< Contidad total de objetos
00302 };
00303 
00304 int AutoRef::m_cont = 0;
00305 
00306 /// Muestra como no es posible que \c lkptr<> maneje algunos ciclos correctamente.
00307 template <class E>
00308 void test_lkptr<E>::test_lkptr_cycle() {
00309     {{  // test::lkptr_cycle()
00310         if ( true ) {
00311             assertTrue( AutoRef::cont() == 0 );
00312             lkptr<AutoRef> paco ( new AutoRef() ); assertTrue( AutoRef::cont() == 1 );
00313             lkptr<AutoRef> lola ( new AutoRef() ); assertTrue( AutoRef::cont() == 2 );
00314             paco->set( lola );
00315             lola->set( paco );
00316         }
00317         assertTrue( AutoRef::cont() == 0 );
00318     }}
00319 }
00320 // AutoRef::Auto-Referencia
00321 
00322 // Esta documentación aparece después para que quede de primera la
00323 // implementación a la que se hace referencia en el \dontinclude
00324 
00325 /** \struct AutoRef
00326     \brief  Clase que se auto-referencia.
00327 
00328     \code
00329      paco        lola
00330      +---+      +---+   - Al destruir el "AutoRef" al que "paco" apunta
00331      | * |      | * |     el destructor lkptr<> destruye a lo que "lola" apunta
00332      +---+      +---+
00333        |          |     - Antes de destruir el "AutoRef" al que "lola" apunta
00334        v          v       el destructor lkptr<> destruye a lo que "paco" apunta
00335     +-----+    +-----+
00336     |  *--|--->|     |  - Esto causa un ciclo infinito de invocaciones de los destructores
00337     |     |<---|--*  |
00338     +-----+    +-----+  - Por eso este programa se cae, pues tiene lkptr<>'s circulares
00339     AutoRef    AutoRef
00340     \endcode
00341 
00342     \dontinclude test_lkptr.cpp
00343     \skipline    AutoRef::Auto-Referencia
00344     \until       AutoRef::Auto-Referencia
00345     \see         test_lkptr<E>::test_lkptr_cycle()
00346 */
00347 
00348 /// Number of elements in vector \c V[].
00349 #define DIM(V) (sizeof(V)/sizeof(*V))
00350 
00351 #if 0
00352     struct Point                          { virtual int val() const { return 0; } };
00353       struct Circle      : public Point   { virtual int val() const { return 1; } };
00354         struct Cilinder  : public Circle  { virtual int val() const { return 2; } };
00355       struct Square      : public Point   { virtual int val() const { return 3; } };
00356         struct Rectangle : public Square  { virtual int val() const { return 4; } };
00357 #else
00358     #include "figures.h" // (Point (Circle (Cilinder)) (Square (Rectangle)))
00359 #endif
00360 
00361 /// Tests that \c lkptr<X> works well with a class hierarchy.
00362 template <class X>
00363 void test_lkptr<X>::inheritance() {
00364     lkptr<Point> VEC[5];
00365     VEC[0].reset(  new Point()         );
00366     VEC[1].reset(    new Circle()      );
00367     VEC[2].reset(      new Cilinder()  );
00368     VEC[3].reset(    new Square()      );
00369     VEC[4].reset(      new Rectangle() );
00370 
00371     for (int i=0; i<DIM(VEC); ++i) {
00372         assertTrue( VEC[i]->val() == i );
00373     }
00374 }
00375 
00376 #include <iostream> // cout
00377 
00378 /// Main test program.
00379 int main() {
00380     test_lkptr<int> tester; // create test
00381     tester.run();              // execute
00382     std::cout << tester.report(); // Save results on "cout"
00383 }
00384 
00385 // EOF: test_lkptr.cpp