ADH_test.h

Ir a la documentación de este archivo.

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

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

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

/** \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.pdf
- 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

- Para simplificar al mínimo la tarea de programar los casos de prueba,
  la implementación completa de \c ADH_test está contenida en el archivo
  de encabezado \c ADH_test.h, por lo que para hacer pruebas basta poner
  esta directiva:
  - <strong>\#include "ADH_test.h"</strong>
- 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 ADH_test_TEST()
  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 puede
  obtener una hilera enorme \c std::string que contiene el registro de
  todas las pruebas que no tuvieron éxito invocando el método
  \c TestCase::toString() o \c TestCase::toXML().
- Para simplificar esta plataforma de pruebas no se hace diferencia entre
  un caso de prueba de prueba existoso y uno que no tiene éxito porque no
  se ha levantado la excepción adecuada. Esto contrasta con JUnit, que
  llama "falla" a un caso de prueba que ha levantado la excepción equivocada.
  Por eso \c TestCase::failureCount() siempre retorna cero \c 0.
    \code
    // Falla vs Error en JUnit
    public void test_Falla () {
        try {
            new ArrayList(10).get( 11 );
            fail("Falla si no tira IndexOutOfBoundsException" ); // falla
        }
        catch (IndexOutOfBoundsException success) { } // Ok
    }
    public void test_Error() {
        assertTrue( 1 == 2 ); // error
    }
    \endcode
- En \c ADH_test.h no se hace diferencia entre "fallas" y "errores".
  - En \c JUnit una "falla" se produce cuando no se levanta la excepción
    adecuada.
  - En \c JUnit un  "error" se produce cuando una aserción resulta falsa.
  - \see http://osdir.com/ml/java.junit.user/2002-06/msg00114.html
  - \see http://www.cs.waikato.ac.nz/~bernhard/314/junit3.8.1/doc/faq/faq.htm#tests_9
  - \see http://search.yahoo.com/search?n=100&p=junit+difference+failure+error
- 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

\dontinclude test_ADH_test.cpp
\skipline    test::Allison()
\until       }}
\see         test_ADH_test::test_Allison()
*/

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

#include <list>      // std::list
#include <string>    // class std::string
#include <sstream>   // class basic_ostringstream<T,Ch>
#include <cstdio>    // memcpy()+strlen()
#include <typeinfo>  // class std::type_info ==> char* typeid().name();
#include <algorithm> // find()

// 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 { }

/// Clase privada que contiene los datos de cada prueba no exitosa.
class TestCaseError {
    const char * m_fname; ///< Nombre del archivo en donde se produjo el error.
    int m_lineno; ///< Número de línea del archivo en donde se produjo el error.
    const char * m_label; ///< Mensaje descriptivo del error.
    bool m_destroy_label; ///< Indica si el destructor debe retornar la memoria de \c m_label.
private:
    TestCaseError() :
        m_fname(""), m_lineno(0), m_label(""), m_destroy_label(false)
    { } ///< Constructor por defecto.
    TestCaseError(const char * fname, int line, const char * label, bool destroy )
        : m_fname(fname), m_lineno(line), m_label(label), m_destroy_label(destroy)
    { } ///< Constructor.
public:
    ~TestCaseError() { if (m_destroy_label) { delete [] m_label; } } ///< Destructor.
    TestCaseError( const TestCaseError& o ) {
        m_fname = o.m_fname; m_lineno = o.m_lineno; m_label = o.m_label;
        m_destroy_label = o.m_destroy_label;
        const_cast<TestCaseError*>(&o)->m_destroy_label = false; // evita doble destrucción de m_label
    //  const_cast<bool>(o.m_destroy_label) = false; // no compila
    } ///< Constructor de copia.
    void operator = ( TestCaseError& o ) {
        m_fname = o.m_fname; m_lineno = o.m_lineno; m_label = o.m_label;
        m_destroy_label = o.m_destroy_label;
        o.m_destroy_label = false; // evita doble destrucción de m_label
    } ///< Copiador usado al insertar en el contenedor.
    friend class TestCase; ///< Caso de prueba.
    template <class TestCase> friend void do_toXML( const TestCase * tc , std::basic_ostringstream<char> & ost );
    template <class TestCase> friend void do_toString( const TestCase * tc , std::basic_ostringstream<char> & ost );
}; // TestCaseError

/// Cada caso de prueba es una instancia derivada de esta clase abstracta.
/// - Siempre es obligatorio implementar \c TestCase::run().
class TestCase {
protected:
    int m_pass; ///< Cantidad de pruebas exitosas
    int m_error; ///< Cantidad de pruebas que han producido error
    const char * m_name; ///< Nombre del caso de prueba
    bool m_test_suite_destroy; ///< Indica si la prueba está en memoria dinámica.
    /// Contenedor para registrar las pruebas que han producido error.
    std::list<TestCaseError> m_errorList;
public:
    TestCase(const char * name=0);
    virtual ~TestCase() { } ///< Destructor
    /// <strong>[virtual]</strong> ==> Ejecuta la prueba y retorna \c "false" si produce error.
    /// <strong>[***]</strong> Siempre es necesario redefinir el método \c run().
    /// \see runBare().
    virtual bool run() = 0;
    void runBare();
    bool Run()     { return run(); } ///< Sinónimo de \c run()
    bool runTest() { return run(); } ///< Sinónimo de \c run()
    virtual void setUp();
    virtual void tearDown();
    int  countTestCases() const { return 1; } ///< Cantidad de casos de prueba que serán ejecutados.
    /// Cantidad total de pruebas realizadas.
    /// - Sinónimo de <code>successCount()+errorCount()+failureCount()</code>.
    /// \see reset().
    int  runCount() const { return successCount()+errorCount(); }
    /// Cantidad de pruebas que han producido error. \see reset().
    virtual int errorCount() const { return m_error; }
    /// Siempre retorna \c 0 (cero): "Cantidad de fallas".
    /// - ADH_test no hace diferencia entre "errores" y "fallas"
    /// \see http://osdir.com/ml/java.junit.user/2002-06/msg00114.html
    int  failureCount() const { return 0; }
    virtual int successCount() const { return m_pass; } ///< Cantidad de pruebas exitosas. \see reset().
    /// Retorna \c "true" si todas las pruebas han sido exitosas.
    /// - Sinónimo de <code>(successCount() == runCount())</code>
    bool wasSuccessful() const { return successCount() == runCount(); }
    virtual void reset();
public:
    /// Obtiene el nombre de la prueba. \see setName().
    std::string getName() const;
    void setName( const char * name=0 );
    virtual const std::string toString() const;
    virtual const std::string summary() const;
    virtual const std::string toXML() const;
    /// Retorna la hilera encabezado \c summary() seguido de errores \c toString().
    const std::string report() const { return summary() + '\n' + toString(); }
    const std::string errorString() const { return toString(); } ///< Sinónimo de \c toString()
    template <class T> static std::string toString( const T & val );
protected:
    void recordSuccess() { ++m_pass; } ///< Registra como exitoso el resultado de una prueba
    void recordError( const char* label, const char* fname, int lineno, bool must_copy=false);
    void recordError( const std::string& label, const char* fname, int lineno );
    void testThis( bool cond, const std::string& label, const char* fname, long lineno);
    void testThis( bool cond, const char*        label, const char* fname, long lineno, bool must_copy=false);
    template <class TestCase> friend void do_toXML( const TestCase * tc , std::basic_ostringstream<char> & ost );
    template <class TestCase> friend void do_toString( const TestCase * tc , std::basic_ostringstream<char> & ost );
    template <class TestCase> friend class TestSuite; ///< Colección de pruebas.
    int  nPass()  const { return m_pass; }  ///< Sinónimo de \c successCount() [OBSOLETO] \deprecated
    int  nError() const { return m_error; } ///< Sinónimo de \c errorCount() [OBSOLETO] \deprecated
private:
    virtual bool iAmTestSuite() const { return false; } ///< Retorna \c false para \c TestCase.
    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
    friend class test_ADH_test; ///< Clase de prueba para \c ADH_test.h
}; // TestCase

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

/** Constructor.
    - Si no se indica el nombre en \c "name", el nombre se obtiene con <code>typeid(*this).name()</code>.

    \dontinclude test_ADH_test.cpp
    \skipline    test::constructor()
    \until       }}
    \see         test_ADH_test::test_constructor()
*/
inline TestCase::TestCase(const char * name) :
    m_pass(0), m_error(0), m_name(name), m_test_suite_destroy(false), m_errorList() { }

/** Elimina todas las pruebas realizadas.
    - Anula los contadores de pruebas porque deja la clase en el estado
      inicial que tuvo al ser construida.
    - Borra el registro de pruebas no exitosas.
    - No borra el nombre de la prueba.

    \dontinclude test_ADH_test.cpp
    \skipline    test::reset()
    \until       }}
    \see         test_ADH_test::test_reset()
*/
inline void TestCase::reset() {
    m_pass =  m_error = 0;
    m_errorList.clear();
}

inline std::string TestCase::getName() const {
    return ( m_name != 0 ? m_name : typeid(*this).name() );
}

/** Le cambia el nombre a la prueba.
    \dontinclude test_ADH_test.cpp
    \skipline    test::setName()
    \until       }}
    \see         test_ADH_test::test_setName()
*/
inline void TestCase::setName( const char * name ) {
    m_name = name;
}

/** Ejecuta la prueba <code>setUp(); run(); tearDown();</code>.
    - A diferencia de \c run(), este método si establece el ambiente
      de prueba invocando \c setUp() y \c tearDown() antes y después
      de hacer la prueba.

    \dontinclude test_ADH_test.cpp
    \skipline    test::run()
    \until       }}
    \see         test_ADH_test::test_run()
*/
inline void TestCase::runBare( ) { setUp(); run(); tearDown(); }

/// Establece el ambiente para la ejecución de la prueba
/// \see TestCase::setUp()
typedef TestCase TestFixture;

/** Establece el ambiente en que se realizará 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>::runBare().
    - A diferencia de \c TestCase::runBare(), el método
      \c TestCase::run() no establece el ambiente de prueba
      porque no invoca ni a  \c TestCase::setUp() antes de
      la prueba ni a \c TestCase::tearDown() después .
    - \c TestSuite<TestCase>::runBare() invoca los métodos
      \c TestCase::setUp() y \c TestCase::tearDown()
      cuando ejecuta cada prueba.
    - Por eso, si el programador cliente quiere que cada
      prueba se ejecute luego de establecer el ambiente de
      la prueba, lo más práctico es que agregue sus
      pruebas a una colección de pruebas \c TestSuite para
      ejecutarlas con \c TestSuite<TestCase>::runBare().
*/
inline void TestCase::setUp() { }

/// Destruye el ambiente de prueba
inline void TestCase::tearDown() {}

/** Efectúa la prueba y registra el resultado.
    - Si la prueba es exitosa sólo incrementa la cantidad de éxitos \c successCount().
    - Si la prueba no tiene éxito 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__".
    - El valor \c "must_copy" indica que es necesario hacer una copia de la
      hilera \c "label", copia que será destruida cuando el registro de
      pruebas no exitosas sea borrado.
    - En la mayor parte de los casos, la hilera \c "label" es una constante
      generada por el preprocesador al usar la macro \c \#cond y por eso su
      memoria no debe ser retornada.

    Este método es invocado usando la macro \c ADH_test_TEST().
    \dontinclude test_ADH_test.cpp
    \skipline    test::testThis()
    \until       }}
    \see         test_ADH_test::test_testThis()
*/
inline void TestCase::testThis( bool cond, const char * label, const char* fname, long lineno, bool must_copy ) {
    if (cond) {
        recordSuccess();
    }
    else {
        recordError( label, fname, lineno, must_copy );
    }
}

inline void TestCase::testThis( bool cond, const std::string& label, const char* fname, long lineno ) {
    testThis( cond, label.c_str(), fname, lineno, true /* must_copy == true */ );
} ///< Sinónimo de \c testThis();

/** Registra que la prueba no tuvo éxito.
    - 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__".
    - El valor \c "must_copy" indica que es necesario hacer una copia de la
      hilera \c "label", copia que será destruida cuando el registro de
      pruebas no exitosas sea borrado.
    - En la mayor parte de los casos, la hilera \c "label" es una constante
      generada por el preprocesador al usar la macro \c \#cond y por eso su
      memoria no debe ser retornada.

    Este método es invocado usando la macro \c ADH_test_ERROR().
*/
inline void TestCase::recordError( const char* label, const char* fname, int lineno, bool must_copy ) {
    if ( must_copy ) {
        size_t len = strlen(label)+1;
        char* str = new char[ len ]; // hace la copia del mensaje de error
        memcpy( str, label, len );
        label = str;
    }
    m_errorList.push_back( TestCaseError ( fname, lineno, label, must_copy ) );
    m_error++;
}

/// Registra que la prueba no tuvo éxito.
/// - En \c ADH_test.h no se hace diferencia entre "fallas" y "errores".
inline void TestCase::recordError( const std::string& label, const char* fname, int lineno ) {
    recordError( label.c_str(), fname, lineno, true /* must_copy == true */ );
/*  Nota: como aquí se obtiene memoria dinámica para "str" hay que marcar
    el campo "TestCase::m_destroy_label" con el valor "true" de manera
    que el destructor de "TestCaseError" retorne esa memoria.
*/
}

/** Hilera "enooorme" que contiene copia del registro de pruebas no exitosas, separados por \c "\n".
    \code
    =\_error: 1 == 0
    =/ (125) X:\DIR\SubDir\test_ADH_test.cpp
    =\_error: 4 == 0
    =/ (128) X:\DIR\SubDir\test_ADH_test.cpp
    \endcode
*/
inline const std::string TestCase::toString() const {
//  typedef basic_ostringstream<char> ostringstream;
    std::basic_ostringstream<char> ost; // ostringstream ost;
    do_toString( this , ost );
    return ost.str();
}

/// Le agrega a \c ost la hilera de todas las pruebas no exitosas de \c *tc.
template <class TestCase>
void do_toString( const TestCase * tc , std::basic_ostringstream<char> & ost ) {
    std::list<TestCaseError>::const_iterator it = tc->m_errorList.begin();
    for ( ; it != tc->m_errorList.end(); ++it) {
        ost << "=\\_error: " << it->m_label << " \n=/ ("
            << it->m_lineno << ") " << it->m_fname << "\n";
    }
    return;
/*  NOTA
    La implementación de "TestCase::toString()" está hecha invocando esta
    función emplantillada para que sea el compilador el responsable de
    remover versiones duplicadas de esta misma rutina, las que se producen
    cuando este archivo de encabezado ("ADH_test.h") es incluido en varios
    archivos "*.cpp". Todo esto hay que hacerlo para que "ADH_test.h" quepa,
    completo, en un único archivo de encabezado.
*/
}

/** Hilera XML que contiene una copia de las pruebas no exitosas.
    \code
    <error file="X:\DIR\SubDir\test_ADH_test.cpp" line="125" message="1 == 0"/>
    <error file="X:\DIR\SubDir\test_ADH_test.cpp" line="128" message="4 == 0"/>
    \endcode
*/
inline const std::string TestCase::toXML() const {
//  typedef basic_ostringstream<char> ostringstream;
    std::basic_ostringstream<char> ost; // ostringstream ost;
    do_toXML( this , ost );
    return ost.str();
}

/// Le agrega a \c ost la hilera de todas las pruebas no exitosas de \c *tc en formato XML.
template <class TestCase>
void do_toXML( const TestCase * tc , std::basic_ostringstream<char> & ost ) {
    std::list<TestCaseError>::const_iterator it = tc->m_errorList.begin();
    for ( ; it != tc->m_errorList.end(); ++it ) {
        ost << "<error file=\"" << it->m_fname
            << "\" line=\"" << it->m_lineno
            << "\" message=\"" << it->m_label  << "\"/>" << std::endl;
    }
    return;
/*  Nota:
    La implementación de "TestCase::toXML()" está hecha invocando a la
    función emplantillada "do_toXML()" para que el compilador se encargue
    de evitar la declaración múltiple que ocurre cuando "ADH_test.h" es
    incluido en varios archivos "*.cpp" diferentes en el mismo proyecto.
*/
}

/// [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.
    - Es más elegante usar assertTrue() que hace lo mismo.
    - Si la prueba \c "cond" tiene éxito invoca el método
      \c TestCase::recordSuccess().
    - Si la prueba \c "cond" no tiene éxito invoca el método
      \c TestCase::recordError().
    - Esta es una una macro que invoca el método
      \c TestCase::testThis().

    \dontinclude test_ADH_test.cpp
    \skipline    test::ADH_test_macro()
    \until       }}
    \see         test_ADH_test::test_ADH_test_macro()
*/
#define ADH_test_TEST(cond) testThis( cond, #cond, __FILE__, __LINE__ )

/// [ADH_test] Macro similar a \c ADH_test_TEST() que usa el mensaje \c "msg".
/// - El mensaje \c "msg" debe ser una hilera literal o un objeto que pueda
///   convertirse en <code>(const char *)</code>.
#define ADH_test_TEST_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
      no tuvo éxito y por eso quiere registrar ese hecho.
    - Está implementado comun una macro que invoca
      el método \c TestCase::recordError().

    \see ADH_test_TEST()
    \code
    if (22==33) {
        ADH_test_ERROR("! (22==33)"); // Registra el error
    }
    \endcode
*/
#define ADH_test_ERROR(msg) recordError( msg, __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().
    \see ADH_test_TEST()
*/
#define ADH_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 no tiene éxito invoca el método
///   \c TestCase::recordError().
/// - Esta es una una macro que invoca el método
///   \c TestCase::testThis().
///  \see ADH_test_TEST()
#define ADH_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 no tiene éxito invoca el método
///   \c TestCase::recordError().
/// - Esta es una una macro que invoca el método
///   \c TestCase::testThis().
/// - Registra el mensaje \c "MSG" si la prueba no tiene éxito.
/// \see ADH_test_TEST()
#define ADH_test_EQUAL_Msg(MSG, expected, actual) \
        testThis( (expected) == (actual), MSG, __FILE__, __LINE__ )

/// Retorna un hilera que contiene el nombre, cantidad de éxitos y cantidad de errores de la prueba.
inline const std::string TestCase::summary() const {
    std::string res = "TestCase [" + getName() + ']';
    res += " (OK: "    + TestCase::toString( successCount() ) + ')';
    res += " (ERROR: " + TestCase::toString( errorCount() )   + ')';
    return res;
}

// ¿¿¿ 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<>()==true por defecto (por si el programador no lo ha implementado)
inline bool check_ok( const unsigned char & ) { return true; } ///< \c check_ok<>()==true por defecto (por si el programador no lo ha implementado)
inline bool check_ok( const signed int &    ) { return true; } ///< \c check_ok<>()==true por defecto (por si el programador no lo ha implementado)
inline bool check_ok( const unsigned int&   ) { return true; } ///< \c check_ok<>()==true por defecto (por si el programador no lo ha implementado)
inline bool check_ok( const signed long &   ) { return true; } ///< \c check_ok<>()==true por defecto (por si el programador no lo ha implementado)
inline bool check_ok( const unsigned long & ) { return true; } ///< \c check_ok<>()==true por defecto (por si el programador no lo ha implementado)
inline bool check_ok( const float &         ) { return true; } ///< \c check_ok<>()==true por defecto (por si el programador no lo ha implementado)
inline bool check_ok( const double &        ) { return true; } ///< \c check_ok<>()==true por defecto (por si el programador no lo ha implementado)
inline bool check_ok( const long double &   ) { return true; } ///< \c check_ok<>()==true por defecto (por si el programador no lo ha implementado)

/// Retorna una hilera que contiene el valor de \c val.
/// - \c toString() with standard C++
template <class T>
std::string TestCase::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) ADH_test_TEST(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) ADH_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) ADH_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) \
        ADH_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;                                  \
            }                                           \
            ADH_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 ( ... ) {                                \
                ADH_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 ) ADH_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 ) ADH_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(     )     ADH_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 ) ADH_test_ERROR(MSG)

#endif // ADH_test_h

// EOF: ADH_test.h

---

Hosted by www.Geocities.ws