test_deque.cpp

Ir a la documentación de este archivo.

// test_deque.cpp (C) 2006 [email protected]

/** \file  test_deque.cpp
    \brief Módulo de prueba para la clase \c deque

    Este código está basado en el trabajo de Chuck Allison
    para probar la clase \c Stack.h

    Aquí lo que se hizo fue implementar esta clase siguiendo
    el paradigma de la biblioteca STL de C++, lo que dio por
    resultado la clase \c deque.
    - http://www.google.com/search?num=100&as_q=Simplest+Unit+Test+Allison
    - http://search.yahoo.com/search?n=100&p=Simplest+Unit+Test+Allison

    \author Adolfo Di Mare <[email protected]>
    \date   2006
*/

#include "deque.h" // Clase de prueba
using namespace std;

// En algún manual debe estar descrito qué significa este error
// - http://www.google.com/search?num=100&as_q=c%2B%2B+C4675+Compiler+Warning
#pragma warning( push, 1 )       // check_ok( Q ); ==> Compiler Warning (level 1) C4675
#pragma warning( disable: 4675 ) // check_ok( Q ); ==> Compiler Warning (level 1) C4675

#include "ADH_test.h" // Módulo para prueba unitaria de programas

/// Clase para probar el contenedor \c deque<T>
template <class T>
class test_deque : public TestCase {
    enum {
        N_REPEAT = 100, ///< Las pruebas se hacen para contenedores de tamaño <code>[0..N_REPEAT-1]</code>
    };
public:
    test_deque() { } ///< Constructor
    void test_deque_deque();
    void test_empty();
    void test_size();
    void test_capacity();
    void test_front();
    void test_front_const();
    void test_back();
    void test_back_const();

    void test_push_front();
    void test_push_back();
    void test_pop_front();
    void test_pop_back();

    void test_at();

    void test_example();

    /// Método base que ejecuta todas las pruebas de la clase.
    bool run() {
        //  Estos los estoy construyendo ahora
        test_example();

        // Lista de métodos a probar
        test_deque_deque();
        test_empty();
   //   test_size();
   //   test_capacity();
        test_front();
        test_front_const();
   //   test_back();
        test_back_const();
        test_push_front();
        test_push_back();
        test_at();

        return nError() == 0;
    }
};

/// \fn void deque<T>::deque( size_type N )
/// \see test_deque<T>::test_deque()

/// Datos de prueba para el constructor y destructor de la clase
template <class T>
void test_deque<T>::test_deque_deque() {
    try {
        deque<T> Q(0);
        fail_Msg("test_deque() ==> Es incorrecto usar contenedores de tamaño cero (0)");
    }
    catch (std::length_error) {
        assertTrue(true); // Esta es la forma de decir: "la prueba sí tuvo éxito"
    }
    for (int i = 1; i<N_REPEAT; ++i) {
        try {
            deque<T> Q(i);
            assertTrue(true);
            assertTrue( check_ok( Q ));
        }
        catch (...) {
            fail_Msg("test_deque() ==> Es correcto usar contenedores de tamaño " + ::toString(i));
        }
    }
}

// Esta es la forma Doxygen de documentar métodos que están en otro lado:
/// \fn bool deque<T>::empty() const
/// \see test_deque<T>::test_empty()

/// Datos de prueba para \c deque<T>::size() && \c deque<T>::capacity() && \c deque<T>::empty().
/// - La idea de esta prueba es crear \c N_REPEAT contenedores de capacidad máxima <code> j in [1..N_REPEAT[ </code>.
///   - Para cada una de estos contenedores, se prueban los 3 métodos variando el principio del
///     contenedor desde el índice \c 0 hasta <code> (N_REPEAT-1) </code> del vector \c m_vec[].
/// - Es necesario metérsele al <em>Rep</em> de la clase para implementar esta prueba.
template <class T>
void test_deque<T>::test_empty() {
    deque<T>::value_type temp;
    for (int i=1; i<N_REPEAT; ++i) { // "i" es la capacidad del contenedor de prueba
        for (int j=0; j<i; ++j) {    // "j" sirve para variar el sitio "m_front" donde comienza el contenedor
            deque<T> Q(i);
            Q.m_front = j; // prueba con todos los valores válidos para Q.m_front == j
            assertTrue(Q.size() == 0);
            assertTrue(Q.empty());
            assertTrue(Q.capacity() == i);
            for (int k=0; k<i; ++k) { // llena de valores el contenedor
                assertTrue(Q.size() == k);
                assertTrue(Q.capacity() == i);
                Q.push_back(temp);
                assertTrue( check_ok( Q ));
                assertTrue(Q.size() == k+1);
                assertTrue(Q.capacity() == i);
            }
        }
    }
}

/// \fn size_type deque<T>::size() const
/// \see test_deque<T>::test_size()

/// Datos de prueba para \c deque<T>::size() && \c deque<T>::capacity() && \c deque<T>::empty()
template <class T>
void test_deque<T>::test_size() { test_empty(); }

/// \fn size_type deque<T>::capacity() const
/// \see test_deque<T>::test_capacity()

/// Datos de prueba para \c deque<T>::size() && \c deque<T>::capacity() && \c deque<T>::empty()
template <class T>
inline void test_deque<T>::test_capacity() { test_size(); }

/// Datos de prueba para \c deque<T>::front() && \c deque<T>::back().
/// - La idea de esta prueba es crear \c N_REPEAT contenedores de capacidad máxima <code> j in [1..N_REPEAT[ </code>.
///   - Para cada una de estos contenedores, se prueba el método \c front() variando el principio del
///     contenedor desde el índice \c 0 hasta <code> (N_REPEAT-1) </code> del vector \c m_vec[].
/// - Es necesario metérsele al <em>Rep</em> de la clase para implementar esta prueba.
/// - Para verficar que el valor que está almacenado en cada posición de \c m_vec[] esta
///   prueba no usa contenedores de tipo \c T (el parámetro de la plantilla). El contenedor de prueba
///   almacena número enteros, \c deque<int>, porque de esta manera se pueden usar las
///   operaciones aritméticas para incrementar paulatinamente el valor agregado al contenedor.
template <class T>
void test_deque<T>::test_front() {
    // m_vec
    //   ||
    //   \/ <1> <2>==m_front    <6>
    // +---+---+---+---+---+---+---+
    // | _ | _ | 0 | 1 | 2 | 3 | _ |
    // +---+---+---+---+---+---+---+
    //  <0>      |-----------+
    // m_front---+  #2  #3  #4
    //            m_size == 4
    for (int i=1; i<N_REPEAT; ++i) { // "i" es la capacidad del contenedor de prueba
        for (int j=0; j<i; ++j) {
            deque<int> Q(i);
            Q.m_front = j; // prueba con todos los valores válidos para Q.m_front == j
            assertTrue(Q.size() == 0);

            for (int k=0; k<i; ++k) { // llena de valores el contenedor
                Q.push_back(k);
                assertTrue( check_ok( Q ));
                assertTrue(Q.front() == 0);
                assertTrue(Q.back() == k);
                assertTrue(Q.size() == k+1);
            }
            assertTrue(Q.front() == 0);
            assertTrue(Q.back() == i-1);
            assertTrue(Q.size()==i);
            for (int k=0; k<i; ++k) { // ahora lo vacea
                assertTrue(Q.front() == k);
                assertTrue(Q.back() == i-1);
                assertTrue(Q.size() == i-k);
                Q.pop_front();
                assertTrue( check_ok( Q ));
            }
            assertTrue_Msg( "Q.size()==" + ::toString(Q.size()) , Q.empty() );
        }
    }
}

/// Datos de prueba para \c deque<T>::front() const
template <class T>
void test_deque<T>::test_front_const() {
    // Sólo se asegura de que sea invocada el método "const"
    // - La lógica de front() se prueba con test_front()
    const deque<T> Q_const(4);
    const_cast< deque<T>& >(Q_const).m_size = 1;
    assertTrue(Q_const.front() == Q_const.front());
}

/// Datos de prueba para \c deque<T>::front() && \c deque<T>::back()
template <class T>
void test_deque<T>::test_back() { test_front(); }

/// Datos de prueba para deque<T>::back() const
template <class T>
void test_deque<T>::test_back_const() {
    // Sólo se asegura de que sea invocada el método "const"
    // - La lógica de back() se prueba con test_back()
    const deque<T> Q_const(4);
    const_cast< deque<T>& >(Q_const).m_size = 1;
    assertTrue(Q_const.back() == Q_const.back());
}

/// Datos de prueba para \c deque<T>::push_front() y \c deque<T>::pop_front()
template <class T>
void test_deque<T>::test_push_front() {
    deque<T>::value_type temp;
    for (int i=1; i<N_REPEAT; ++i) {
        for (int j=0; j<i; ++j) {
            deque<T> Q(i);
            assertTrue(Q.size() == 0);
            Q.m_front = j; // prueba con todos los valores válidos para Q.m_front == j
            assertTrue(Q.size() == 0);
                        
                        int k;

            for (k=0; k<i; ++k) { // llena de valores el contenedor
                assertTrue(Q.size() == k);
                Q.push_front(temp);
                assertTrue( check_ok( Q ));
                assertTrue(Q.size() == k+1);
            }
 
            for (; k>0; --k) { // ahora lo vacea
                assertTrue(Q.size() == k);
                Q.pop_front();
                assertTrue( check_ok( Q ));
                assertTrue(Q.size() == k-1);
            }
            if (!Q.empty()) {
                assertTrue_Msg( "k==" + ::toString(k) , k==0 );
                assertTrue_Msg( "Q.size()==" + ::toString(Q.size()) , Q.empty() );
            }
        }
    }
}

/// Datos de prueba para \c deque<T>::push_back() y \c deque<T>::pop_back()
template <class T>
void test_deque<T>::test_push_back() {
    deque<T>::value_type temp;
    for (int i=1; i<N_REPEAT; ++i) {
        for (int j=0; j<i; ++j) {
            deque<T> Q(i);
            assertTrue(Q.size() == 0);
            Q.m_front = j; // prueba con todos los valores válidos para Q.m_front == j
            assertTrue(Q.size() == 0);

                        int k;
            for (k=0; k<i; ++k) { // llena de valores el contenedor
                assertTrue(Q.size() == k);
                Q.push_back(temp);
                assertTrue( check_ok( Q ));
                assertTrue(Q.size() == k+1);
            }

            for (; k>0; --k) { // ahora lo vacea
                assertTrue(Q.size() == k);
                Q.pop_back();
                assertTrue( check_ok( Q ));
                assertTrue(Q.size() == k-1);
            }
            if (!Q.empty()) {
                assertTrue_Msg( "k==" + ::toString(k) , k==0 );
                assertTrue_Msg( "Q.size()==" + ::toString(Q.size()) , Q.empty() );
            }
        }
    }
}

/// Datos de prueba para \c deque<T>::pop_front()
template <class T>
inline void test_deque<T>::test_pop_front() { test_push_front(); }

/// Datos de prueba para \c deque<T>::pop_back()
template <class T>
inline void test_deque<T>::test_pop_back() { test_push_back(); }

/// Datos de prueba para \c deque<T>::at().
///  - Es necesario metérsele al <em>Rep</em> de la clase para implementar esta prueba.
///  - Para verficar que el valor que está almacenado en cada posición de \c m_vec[] esta
///    prueba no usa contenedores de tipo \c T (el parámetro de la plantilla). El contenedor de prueba
///    almacena número enteros, \c deque<int>, porque de esta manera se pueden usar las
///    operaciones aritméticas para incrementar paulatinamente el valor agregado al contenedor.
///  - Independientemente de cuál sea el tipo \c T, la prueba siempre se hace usando enteros para
///    poder verificar qué es lo que está almacenado en \c Q[i].
///    - Se puede probar con todos los valores para \c Q.capacity() en \c [0..N_REPEAT[
///      - Sin embargo, esta prueba dura DEMASIADO pues cada vez que se levanta
///        una excepción la máquina se traga el CPU haciendo cálculos.
///      - En lugar de probar con todos los valores, se prueba sólo con los del vector
///        \c Pruebe_Con_Estos[].
template <class T>
void test_deque<T>::test_at() {
    deque<int> Q(4); // cualquier n>0 funciona
    deque<int>::value_type *remember = Q.m_vec; // vector viejo
    try {
        assertTrue(Q.capacity() < N_REPEAT*2);
        try {
            // "Agranda" el vector a Q para poder usar valores "fuera de rango"
            deque<int>::value_type *Doble_Vec;
            Doble_Vec = new deque<int>::value_type [ 2*N_REPEAT ];
            Q.m_vec = Doble_Vec; // usa el vectorsote de prueba
            assertTrue( check_ok( Q ));
        }
        catch (...) {
            fail_Msg("test_at()");
            throw;
        }

        // Prueba con algunos para que la prueba no dure demasiado
        int Pruebe_Con_Estos[] ={ 1,2,3,4,5, 7,9,11,12,13, 23,50, 77,N_REPEAT-2,N_REPEAT-1 };
        assertTrue(77<N_REPEAT-2);
        int CUANTOS = sizeof(Pruebe_Con_Estos)/sizeof(*Pruebe_Con_Estos);
        int i,j,k;
        for (i=0; i<CUANTOS; ++i) {
            for (j=0; j<Pruebe_Con_Estos[i]; ++j) {
                Q.m_front = j; // prueba con todos los valores válidos para Q.m_front == j
                Q.m_size = 0; // contenedor vacío
                Q.m_capacity = Pruebe_Con_Estos[i]; // usa Pruebe_Con_Estos[i] en lugar de "i"

                // marca todos los campos del vector como valores "fuera de rango"
                for (k=0; k<2*N_REPEAT; ++k) {
                    Q.m_vec[k] = -1;
                }
                // Pone en el contenedor los valores 1.2....N_REPEAT
                for (k=0; k<Pruebe_Con_Estos[i]; ++k) {
                    Q.push_back(k);
                }
                for (k=0; k<Pruebe_Con_Estos[i]; ++k) {
                    assertTrue( k == Q[k]    );
                    assertTrue( k == Q.at(k) );
                }
                // Euler dijo que la suma (1..N_REPEAT) se calcula por fórmula
                //   1 + 2 + ... +n-1 ==\   n*(n-1) / 2
                //  n-1+         + 1  ==/
                int suma_euler = Q.m_capacity * (Q.m_capacity - 1) / 2;
                // Ahora suma los que sí están dentro del vector
                deque<int>::value_type suma_real = 0;
                for (k=0; k<Pruebe_Con_Estos[i]; ++k) {
                    deque<int>::value_type val = Q.front();
                    suma_real += val;
                    Q.pop_front();
                }
                assertTrue(suma_euler == suma_real);

                // Aquí debe haber únicamente Q.m_capacity valores diferentes de -1
                int count=0;
                for (k=0; k<2*N_REPEAT; ++k) {
                    if (Q.m_vec[k] >= 0) {
                        ++count; // cuenta los que están en rango
                    }
                    else {
                        try { // estos están fuera de rango
                            int bomba = Q.at(k);
                            fail_Msg("test_at()");
                        }
                        catch (std::out_of_range) {
                            // estos son los que están "fuera de rango" de acuerdo a push_back()
                            assertTrue(true);
                        }
                        catch (...) {
                            fail_Msg("test_at()");
                            throw;
                        }
                    }
                }
                assertTrue(Q.m_capacity==count);
            }
        }
    }
    catch (...) {
        // Si cae aquí es porque algo falló.
        // - No hay que hacer nada porque en otro lugar ya el
        //   problema fue registrado invocando fail_Msg("...");
    }
    // se deshace del "vectorsototote"
    delete [] Q.m_vec;
    Q.m_vec = remember; // restaura Q.m_vec[]
    // Ahora el destructor de "Q" se encarga de devolver 
    // la memoria dinámica que está usando m_vec[]
}

/// Ejemplo de uso de la clase \c deque<T>.
template <class T>
void test_deque<T>::test_example() {
    const unsigned SIZE = 7; // Capacidad del contenedor de prueba \c Q<T> para \c test_example()
    {   // La capacidad del contenedor debe ser definido en el momento de construcción
        try { // Es incorrecto usar contenedores de tamaño cero (0)
            deque<T> Q(0); // Es incorrecto usar contenedores de capacidad cero (0)
            fail_Msg("deque<unsigned> Q(0);");
        }
        catch (std::logic_error&) {
            assertTrue(true);
        }
        catch (...) {
            fail_Msg("Execpción inesperada");
        }
    }
    assertTrue(SIZE > 0);

    {   // El contenedor está vacío y su tamaño debe ser cero (0)
        deque<T> Q(SIZE);
        assertTrue( check_ok( Q ));
        assertTrue(Q.size() == 0);
        try { // Es incorrecto usar un valor del contenedor si el contenedor está vacío
            Q.front();
            fail_Msg("Q.front();");
        }
        catch (std::logic_error&) {
            assertTrue(true);
        }
        catch (...) {
            fail_Msg("Q.front();");
        }

        try { // Es incorrecto eliminar un valor del contenedor si el contenedor está vacío
            Q.pop_front();
            fail_Msg("Q.pop_front();");
        }
        catch (std::logic_error&) {
            assertTrue(true);
        }
        catch (...) {
            fail_Msg("Q.pop_front();");
        }
        assertTrue( check_ok( Q ));
    }

    {   // Es incorrecto almacenar más de Q.capacity() valores en el contenedor
        deque<unsigned> Q(SIZE);
        try {
            for (unsigned i = 0; i < SIZE; ++i) {
                Q.push_back(i);
            }
            assertTrue(true);
            assertTrue( check_ok( Q ));
        }
        catch (...) {
            fail_Msg("Execpción inesperada");
            return;
        }

        assertTrue(Q.size() == SIZE);
        assertTrue(Q.back() == SIZE-1);

        try { // Ya el contenedor está llena y no le caba nada más
            Q.push_back(SIZE);
            fail_Msg("Q.push_back(SIZE);");
        }
        catch (std::logic_error&) {
            assertTrue(true);
        }
        catch (...) {
            fail_Msg("Execpción inesperada");
        }

        for (unsigned i = 0; i < SIZE; ++i) {
            assertTrue(Q.front() == i); // ¿¿¿ AQUI ???
            try {
                Q.pop_front();
                assertTrue(true);
            }
            catch (...) {
                fail_Msg("Q.pop_front();");
                return;
            }
        }
        assertTrue(Q.size() == 0);
        assertTrue( check_ok( Q ) );

        try { // Ya el contenedor está vacío y no se le puede sacar nada más
            Q.pop_front();
            fail_Msg("Q.pop_front();");
        }
        catch (std::logic_error&) {
            assertTrue(true);
        }
        catch (...) {
            fail_Msg("Q.pop_front();");
        }
    }
}

/// Prueba \c TestCase.
/// - Como ocurre con la mayor parte de los programas de prueba,
///   este programa no imprime nada, pues un programa de prueba
///   sólo debiera imprimir un mensaje de error si alguna prueba
///   falla, en cuyo caso el programador debería revisar la
///   rutina o método que quebró la implementación.
/// - Lo que este programa imprime es una salida muy simple:
///   \code
///   TestCase "class deque_test<int>":
///       OK: 8380993 ERROR: 0
///   TestCase "class deque_test<float>":
///       OK: 8380993 ERROR: 0
///   \endcode
int main_TestCase() {
    test_deque<int>   Test_I;
    test_deque<float> Test_F;

    Test_I.run();
    Report( cout, Test_I );
    Test_F.run();
    Report( cout, Test_F );
    return Test_I.nError() + Test_F.nError();
}

/// Programa principal que ejecuta todas las pruebas.
int main() {
    return main_TestCase();
}

#pragma warning( pop ) // check_ok( Q ); ==> Compiler Warning (level 1) C4675

// EOF: test_deque.cpp

---

Hosted by www.Geocities.ws