ADH_test.h

Ir a la documentación de este archivo.

// ADH_test.h (C) 2006  [email protected]

/** \file  ADH_test.h
    \brief Módulo para prueba unitaria de programas.

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

/** \mainpage

\section sec-01 Módulo para prueba unitaria de programas

El archivo de encabezado \c ADH_test.h apoya la escritura de módulos de prueba de
unitaria programas. El modelo que se usa para esta implementación es
similar al expuesto en este artículo "The Simplest Automated Unit
Test Framework That Could Possibly Work" de Chuck Allison, que se
puede obtener aquí:
- http://www.stickyminds.com/getfile.asp?ot=XML&id=3129&fn=XDD3129filelistfilename1%2Epdf
- 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

- Este marco de pruebas es similar a JUnit, pues se presume que en
  el futuro los estudiantes usarán Java como su lenguaje principal
  para desarrollo de programas (pues usan C++ sólo para adiestrarse
  profundamente en técnicas de programación).
  \see http://search.yahoo.com/search?n=100&p=JUnit+Java
- Como el lenguaje C++ no tiene un mecanismo similar al de "reflexión"
  de Java, en cada prueba fallida se registra la condición de prueba
  exacta, obtenida a través de una invocación de la macro \c TEST_THIS()
  que registra el nombre del archivo \c __FILE__ y el renglón \c __LINE__
  de la prueba.
  \see http://search.yahoo.com/search?n=100&p=reflection+Java
- Para simplificar este marco de pruebas no se usa la clase \c TestResult
  que sirve para acumular resultados de las pruebas. En su lugar, se usa
  una hilera enorme, implementada con \c std::string.
- Para simplificar esta plataforma de pruebas, no se hace diferencia entre
  un caso de prueba de prueba existoso y uno que tiene éxito porque se
  ha levantado la excepción adecuada. Esto contrasta con JUnit, que llama
  "falla" a un caso de prueba exitoso que ha levantado una excepción. Por 
  eso los valor
- En JUnit la clase \c TestCase es una subclase de \c Assert; aquí no existe
  la clase \c Assert pero para mantener una leve compatibiliidad sí se provée
  una funcionalidad similar con macros cuyo nombres comienzan con "assert".
  \see http://search.yahoo.com/search?n=100&p=JUnit+Java+Assert+Method
*/

#ifndef ADH_test_h
#define ADH_test_h ///< Evita la inclusión múltiple

#include <string>      // class std::string
#include <sstream>     // class basic_ostringstream<T,Ch>
//#include <limits.h>    //

// using namespace std;
/// Definido por la biblioteca C++ estándar.
namespace std {} // Está acá para que Doxygen lo documente

/// Escuela de Ciencias de la Computación e Informática.
/// \see http:www.ecci.ucr.ac.cr
namespace ECCI { }

/// Establece el ambiente en que se realizará cada prueba.
/// - \c TestSuite<TestCase>::run() invoca los métodos
///   \c TestCase::setUp() y \c TestCase::tearDown()
///   cuando ejecuta cada prueba.
/// - Como \c TestCase::run() es un método abstracto,
///   para facilitar la programación lo usual es que el
///   programador no incluya invocaciones a
///   \c TestCase::setUp() y \c TestCase::tearDown()
///   pues es más simple dejar que lo haga
///   \c TestSuite<TestCase>::run().
/// - Por eso, si el programador cliente quiere que cada
///   prueba se ejecute luego de establecer el ambiente con
///   su \c TestFixture, lo más práctico es que agregue sus
///   pruebas a una colección de pruebas \c TestSuite.
class TestFixture {
public:
    virtual void setUp() { } ///< Establece el ambiente de prueba
    virtual void tearDown() { } ///< Destruye el ambiente de prueba
//  virtual ~TestCase() { tearDown(); } ///< Destructor
}; // TestFixture

/// NO IMPLEMENTADO ==> Colector genérico de resultados de prueba.
/// - No está implementado para \c ADH_test.h
/// - En \c ADH_test.h se usa una hilera \c std::string para colectar
///   todos los resultados. \see \c TestCase::toString().
/// - C++ tiene la ventaja sobre Java porque el programador puede
///   usar las macros \c __FILE__ y \c __LINE__  para registrar el
///   sitio en que se produce un error en tiempo de ejecución.
class TestResult {
    private: TestResult(); ///< Prohibe crear objetos de tipo \c TestResult.
};

/// NO IMPLEMENTADO ==> Clase abastracta para ejecutar las pruebas y recolectar los resultados.
/// - No está implementado para \c ADH_test.h
/// - En \c ADH_test.h se usa una hilera \c std::string para colectar
///   todos los resultados. \see \c TestCase::toString().
class Test {
private: Test(); ///< Prohibe crear objetos de tipo \c Test.
public:
    /// Retorna la cantidad de pruebas a realizar
    virtual int countTestCases() = 0;
    /// Ejecuta la prueba y recolecta sus resultados en \c result
    virtual void run(TestResult& result) = 0;
};

#include <typeinfo.h>  // class std::type_info ==> char* typeid().name();

/// Cada caso de prueba es una instancia derivada de esta clase abstracta.
/// - Siempre es obligatorio implementar \c TestCase::run().
class TestCase : public TestFixture {
protected:
    int m_pass; ///< Cantidad de pruebas exitosas
    int m_error; ///< Cantidad de pruebas que han fallado
    const char * m_name; ///< Nombre del caso de prueba
    /// Hilera "enooorme" para registrar los mensajes de pruebas fallidas, separados por \c "\n"
    std::string m_errorString;
public:
    TestCase(const char * name=0);
    virtual ~TestCase() { }  ///< Destructor
    virtual bool run() = 0; ///< Ejecuta la prueba y retorna \c "false" si falla
    bool Run()        { return run(); } ///< Sinónimo de \c run()
    bool runTest()    { return run(); } ///< Sinónimo de \c run()
    int nPass() const { return m_pass; } ///< Cantidad de pruebas exitosas
    int nError() const { return m_error; } ///< Cantidad de pruebas que han fallado
    void recordSuccess() { ++m_pass; } ///< Registra como exitoso el resultado de una prueba
    virtual void reset() { m_pass =  m_error = 0; m_errorString = ""; } ///< Anula los contadores de pruebas
public:
    int countTestCases() const { return nPass()+nError(); } ///< Cantidad de pruebas realizadas
    /// Obtiene el nombre de la prueba
    std::string getName() const { return ( m_name != 0 ? m_name : typeid(*this).name()); }
    void setName( const char * name=0 ) { m_name = name; } ///< Le cambia el nombre a la prueba
    /// Hilera "enooorme" para registrar los mensajes de pruebas fallidas, separados por \c "\n"
    const std::string& toString() const { return m_errorString; }
    const std::string& errorString() const { return toString(); } ///< Sinónimo de \c toString()
protected:
    void recordError( const std::string& lbl, const char* fname, int lineno);
    void testThis( bool cond, const std::string& lbl, const char* fname, long lineno);
    void testThis( bool cond, const char*        lbl, const char* fname, long lineno) {
         testThis( cond, std::string(lbl), fname, lineno);
    } ///< Sinónimo de \c testThis()
private:
    TestCase(const TestCase&);            ///< \c "private" evita la copia de casos de prueba
    TestCase& operator=(const TestCase&); ///< \c "private" evita la copia de casos de prueba
}; // TestCase

/// NO IMPLEMENTADO ==> Colección de pruebas.
class TestSuite : public TestCase { };

inline TestCase::TestCase(const char * name) : m_pass(0), m_error(0), m_name(name), m_errorString() {
    m_errorString = "";
}  ///< Constructor

/** Efectúa la prueba y registra el resultado.
    - Si la prueba es exitosa sólo incrementa la cantidad de éxitos \c nPass().
    - Si la prueba falla reporta en \c toString()   el hecho.
    - La prueba es \c "cond".
    - Los valores \c "fname" y \c "lineno" indican el archivo y el renglón
      en donde se ejecuta la prueba.
    - Usualmente los valores de \c "fname" y \c "lineno" se obtienen con
      las macros globales \c "__FILE__" y \c "__LINE__".

    Este método es invocado usando la macro homónima \c TEST_THIS()  */
inline void TestCase::testThis( bool cond, const std::string& lbl, const char* fname, long lineno) {
    if (cond) {
        recordSuccess();
    }
    else {
        recordError(lbl, fname, lineno);
    }
}

/** Registra la falla de la prueba y luego lo acumula en la hilera de fallas \c toString().
    - Los valores \c "fname" y \c "lineno" indican el archivo y el renglón
      en donde se ejecuta la prueba.
    - Usualmente los valores de \c "fname" y \c "lineno" se obtienen con
      las macros globales \c "__FILE__" y \c "__LINE__".

    Este método es invocado usando la macro \c TEST_ERROR() */
inline void TestCase::recordError( const std::string& lbl, const char* fname, int lineno) {
//  typedef basic_ostringstream<char> ostringstream;
    std::basic_ostringstream<char> ost; // ostringstream ost;
    ost << "=\\_error: " << lbl << " \n=/ (" << lineno << ") " << fname << "\n";
    m_errorString += ost.str();
    m_error++;
}

/// [ADH_test] Macros propios de \c ADH_test.h
#define TEST_ADH_test()
#undef  TEST_ADH_test

/// [ADH_test] Efectúa la prueba \c cond y registra el resultado.
/// - Si la prueba \c cond tiene éxito invoca el método
///   \c TestCase::recordSuccess()
/// - Si la prueba \c cond falla invoca el método
///   \c TestCase::recordFail()
/// - Esta es una una macro que invoca el método
///   \c TestCase::testThis()
///   \code
///   TEST_THIS("0 != 1"); // Siempre tiene éxito
///   testThis(0 != 1, "0 != 1", __FILE__, __LINE__ ); // Siempre tiene éxito
///   \endcode
#define TEST_THIS(cond) testThis( cond, #cond, __FILE__, __LINE__ )

/// [ADH_test] Macro similar a \c TEST_THIS() que usa el mensaje \c msg en caso de falla.
/// - El mensaje \c msg debe ser una hilera literal o un objeto que pueda
///   convertirse en <code>const char *</code>
#define TEST_THIS_Msg(msg, cond) testThis( cond, msg, __FILE__, __LINE__ )

/// [ADH_test] Registra como "error" el resultado de una prueba.
/// - El programador cliente es quien determinó que la prueba
///   falló y por eso quiere registrar ese hecho.
/// - Está implementado comun una macro que invoca
///   el método \c TestCase::recordError()
///
///   \code
///   if (22==33) {
///       TEST_ERROR("22 != 33"); // Registra que la prueba falló
///   }
///   \endcode
#define TEST_ERROR(str) recordError( str, __FILE__, __LINE__ )

/// [ADH_test] Registra como "exitoso" el resultado de una prueba.
/// - El programador cliente es quien determinó que la prueba
///   fue exitosa y por eso quiere registrar ese hecho.
/// - Generalmente se usa después de atrapar una excepción que
///   se supone debió ser lanzada como resultado de la prueba.
/// - Está implementado comun una macro que invoca
///   el método \c TestCase::recordSuccess()
///
///   \code
///   queue<T> Q(SIZE); // la cola "Q" está vacía ==> no tiene "front()"
///   try {
///       Q.front();  // Es incorrecto usar un valor de la cola si la cola está vacía
///       TEST_ERROR("Q.front();"); // Fallaría si "front()" no levanta la excepción
///    }
///    catch (std::logic_error&) {
///       TEST_SUCCESS(); // Esto es lo correcto pues "front()" levanta "logic_error" para unca cola vacía
///   }
///   \endcode
#define TEST_SUCCESS() recordSuccess()

/// [ADH_test] Efectúa la prueba para determinar si <code>expected == actual</code>.
/// - Si la prueba tiene éxito invoca el método
///   \c TestCase::recordSuccess()
/// - Si la prueba falla invoca el método
///   \c TestCase::recordFail()
/// - Esta es una una macro que invoca el método
///   \c TestCase::testThis()
#define TEST_EQUAL(expected, actual) \
        testThis( (expected) == (actual), #expected " == " #actual, __FILE__, __LINE__ )

/// [ADH_test] Efectúa la prueba para determinar si <code>expected == actual</code>.
/// - Si la prueba tiene éxito invoca el método
///   \c TestCase::recordSuccess()
/// - Si la prueba falla invoca el método
///   \c TestCase::recordFail()
/// - Esta es una una macro que invoca el método
///   \c TestCase::testThis()
/// - Registra el mensaje \c MSG si la prueba falla.
#define TEST_EQUAL_Msg(MSG, expected, actual) \
        testThis( (expected) == (actual), MSG, __FILE__, __LINE__ )

/// Operación de grabado que permite reportar el resultado de la prueba \c test.
/// - Graba en \c COUT el nombre, cantidad de éxitos y cantidad de errores.
std::ostream & operator << (std::ostream& COUT, const TestCase& test) {
    COUT << "TestCase \""  << test.getName() << "\":\n"
         << "\tOK: "       << test.nPass()
         << "\tERROR: "    << test.nError() << "\n";
    return COUT;
}

/// Graba en \c "COUT" el resultado de la prueba \c test.
/// - Retorna la cantidad total de errores \c test.nError().
/// - Además, graba la cantidad de pruebas exitosas y erróneas.
/// - Si hubo pruebas no exitosas, graba los mensajes de error correspondientes.
inline long Report( std::ostream& COUT, const TestCase &test ) {
    COUT << test;
    if (test.nError() != 0) {
        COUT << test.errorString();
    }
    return test.nError();
}

// ¿¿¿ TestSuite ???

//inline bool check_ok<int>( const int & )      { return true; }
//template<class unsigned> inline bool check_ok( const unsigned & ) { return true; }
//template<class int> inline bool check_ok( const long & )     { return true; }
//template<class int> inline bool check_ok( const flota   & )  { return true; }
//template<class int> inline bool check_ok( const double & )   { return true; }

template <class T> bool check_ok( const T& ); ///< Declaración genérica para \c check_ok()
inline bool check_ok( const signed char &   ) { return true; } ///< \c check_ok<>()
inline bool check_ok( const unsigned char & ) { return true; } ///< \c check_ok<>()
inline bool check_ok( const signed int &    ) { return true; } ///< \c check_ok<>()
inline bool check_ok( const unsigned int&   ) { return true; } ///< \c check_ok<>()
inline bool check_ok( const signed long &   ) { return true; } ///< \c check_ok<>()
inline bool check_ok( const unsigned long & ) { return true; } ///< \c check_ok<>()
inline bool check_ok( const float &       )   { return true; } ///< \c check_ok<>()
inline bool check_ok( const double &      )   { return true; } ///< \c check_ok<>()
inline bool check_ok( const long double & )   { return true; } ///< \c check_ok<>()

/// Retorna una hilera que contiene el valor de \c val.
/// - \c toString() with standard C++
template <class T>
std::string toString( const T & val ) {
//  typedef basic_ostringstream<char> ostringstream;
    std::basic_ostringstream<char> temp; // ostringstream temp;
    temp << val;
    return temp.str( );
}

/// [CppUnit] Macros propios de \c CppUnit http://cppunit.sourceforge.net/doc/lastest
#define CPPUNIT_ADH_test()
#undef  CPPUNIT_ADH_test

/// [CppUnit] Assertions that a condition is true.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga0
#define CPPUNIT_ASSERT(condition) TEST_THIS(condition)

/// [CppUnit] Assertion with a user specified message.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga1
#define CPPUNIT_ASSERT_MESSAGE(message, condition) CPPUNIT_ASSERT(condition)

/// [CppUnit] Fails with the specified message.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga2
#define CPPUNIT_FAIL(message) TEST_ERROR(message)

/// [CppUnit] Asserts that two values are equals.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga3
#define CPPUNIT_ASSERT_EQUAL(expected, actual) TEST_EQUAL(expected, actual)

/// [CppUnit] Asserts that two values are equals, provides additional messafe on failure.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga4
#define CPPUNIT_ASSERT_EQUAL_MESSAGE(message, expected, actual) \
        TEST_EQUAL_Msg(message, expected, actual)

/// [CppUnit] Macro for primitive value comparisons.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga5
#define CPPUNIT_ASSERT_DOUBLES_EQUAL(expected, actual, delta)                 \
        assertEquals_Delta(expected, actual, delta)

/// [CppUnit] Asserts that the given expression throws an exception of the specified type.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga6
#define CPPUNIT_ASSERT_THROW(expression, ExceptionType)  \
        do {                                             \
            bool cpputExceptionThrown_ = false;          \
            try {                                        \
                expression;                              \
            } catch ( const ExceptionType & ) {          \
                cpputExceptionThrown_ = true;            \
            }                                            \
                                                         \
            if ( cpputExceptionThrown_ ) {               \
                break;                                   \
            }                                            \
            TEST_ERROR(                                  \
                "Expected exception: " #ExceptionType )  \
        } while ( false )

/// [CppUnit] Asserts that the given expression does not throw any exceptions.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga7
#define CPPUNIT_ASSERT_NO_THROW(expression)                  \
        do {                                                 \
            try {                                            \
                expression;                                  \
            } catch ( ... ) {                                \
                TEST_ERROR("Unexpected exception caught");   \
            }                                                \
        } while ( false )

/// [CppUnit] Asserts that an assertion fail.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga8
#define CPPUNIT_ASSERT_ASSERTION_FAIL(assertion)               \
        CPPUNIT_ASSERT_THROW( assertion, CPPUNIT_NS::Exception )

/// [CppUnit] Asserts that an assertion pass.
/// \see http://cppunit.sourceforge.net/doc/lastest/group___assertions.html#ga9
#define CPPUNIT_ASSERT_ASSERTION_PASS(assertion) \
        CPPUNIT_ASSERT_NO_THROW( assertion )

// /// Concatena la hilera \c THIS con la hilera \c THAT
// #define ADH_test_CAT( THIS, THAT ) (std::string(THIS) + std::string(THAT).c_str()

#define JUnit_ADH_test()
#undef  JUnit_ADH_test

/// [JUnit] Macros propios de \c JUnit http://junit.sourceforge.net/javadoc/junit/framework/Assert.html
///  Asserts that two objects are equal.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertEquals(java.lang.Object,%20java.lang.Object)
#define assertEquals(          EXPECTED, ACTUAL ) TEST_EQUAL(EXPECTED, ACTUAL)
///  Asserts that two objects are equal (with message).
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertEquals(java.lang.String,%20java.lang.Object,%20java.lang.Object)
#define assertEquals_Msg( MSG, EXPECTED, ACTUAL ) TEST_EQUAL_Msg(MSG, EXPECTED, ACTUAL)

/// [JUnit] Asserts that a condition is true.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertTrue(boolean)
#define assertTrue(           CONDITION ) testThis( CONDITION, #CONDITION, __FILE__, __LINE__ )
/// [JUnit] Asserts that a condition is true (with message).
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertTrue(java.lang.String,%20boolean)
#define assertTrue_Msg( MSG,  CONDITION ) testThis( CONDITION,  MSG,       __FILE__, __LINE__ )

/// [JUnit] Asserts that a condition is false.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertFalse(boolean)
#define assertFalse(          CONDITION ) testThis( !(CONDITION), "!(" #CONDITION ")", __FILE__, __LINE__ )
/// [JUnit] Asserts that a condition is false (with message).
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertFalse(java.lang.String,%20boolean)
#define assertFalse_Msg( MSG, CONDITION ) testThis( !(CONDITION),       MSG,           __FILE__, __LINE__ )

#include <math.h> // fabs()
/// [JUnit] Asserts that two doubles are equal concerning a delta.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertEquals(double,%20double,%20double)
#define assertEquals_Delta(EXPECTED, ACTUAL, DELTA ) \
        testThis( fabs( double(EXPECTED) -  double(ACTUAL) ) < double(DELTA), \
        "|"  #EXPECTED "-" #ACTUAL "| < " #DELTA,  __FILE__, __LINE__ )

/// [JUnit] Asserts that two doubles are equal concerning a delta (with message).
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertEquals(java.lang.String,%20double,%20double,%20double)
#define assertEquals_Delta_Msg( MSG, EXPECTED, ACTUAL, DELTA ) \
        testThis( fabs( double(EXPECTED) -  double(ACTUAL) ) < double(DELTA), \
        MSG, __FILE__, __LINE__ )

/// [JUnit] Asserts that an object is null.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertNull(java.lang.Object)
#define assertNull(OBJECT)    testThis( 0==&(OBJECT), "assertNull("    #OBJECT ")", __FILE__, __LINE__ )
/// [JUnit] Asserts that an object isn't null.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertNotNull(java.lang.Object)
#define assertNotNull(OBJECT) testThis( 0!=&(OBJECT), "assertNotNull(" #OBJECT ")", __FILE__, __LINE__ )

/// [JUnit] Asserts that two objects refer to the same object.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertSame(java.lang.Object,%20java.lang.Object)
#define assertSame(THIS, THAT) testThis(    &(THIS)==&(THAT), "assertSame("    #THIS ", " #THAT ")", __FILE__, __LINE__ )
///  Asserts that two objects do not refer to the same object.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#assertNotSame(java.lang.Object,%20java.lang.Object)
#define assertNotSame(THIS, THAT) testThis( &(THIS)!=&(THAT), "assertNotSame(" #THIS ", " #THAT ")", __FILE__, __LINE__ )

/// [JUnit] Fails a test with no message.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#fail()
#define fail(     )     TEST_ERROR("ERROR")
/// [JUnit] Fails a test with the given message.
/// \see http://junit.sourceforge.net/javadoc/junit/framework/Assert.html#fail(java.lang.String)
#define fail_Msg( MSG ) TEST_ERROR(MSG)

#endif // ADH_test_h

// EOF: ADH_test.h

---

Hosted by www.Geocities.ws