ADH_test.h

Go to the documentation of this file.

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

#ifndef ADH_test_h
#define ADH_test_h 

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

// using namespace std;
namespace std {} // Está acá para que Doxygen lo documente

namespace ECCI { }

class TestFixture {
public:
    virtual void setUp() { } 
    virtual void tearDown() { } 
//  virtual ~TestCase() { tearDown(); } ///< Destructor
}; // TestFixture

class TestResult {
    private: TestResult(); 
};

class Test {
private: Test(); 
public:
    virtual int countTestCases() = 0;
    virtual void run(TestResult& result) = 0;
};

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

class TestCase : public TestFixture {
protected:
    int m_pass; 
    int m_error; 
    const char * m_name; 

    std::string m_errorString;
public:
    TestCase(const char * name=0);
    virtual ~TestCase() { }  
    virtual bool run() = 0; 
    bool Run()        { return run(); } 
    bool runTest()    { return run(); } 
    int nPass() const { return m_pass; } 
    int nError() const { return m_error; } 
    void recordSuccess() { ++m_pass; } 
    virtual void reset() { m_pass =  m_error = 0; m_errorString = ""; } 
public:
    int countTestCases() const { return nPass()+nError(); } 

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

    const std::string& toString() const { return m_errorString; }
    const std::string& errorString() const { return 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);
    } 
private:
    TestCase(const TestCase&);            
    TestCase& operator=(const TestCase&); 
}; // TestCase

class TestSuite : public TestCase { };

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

inline void TestCase::testThis( bool cond, const std::string& lbl, const char* fname, long lineno) {
    if (cond) {
        recordSuccess();
    }
    else {
        recordError(lbl, fname, lineno);
    }
}

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++;
}

#define TEST_ADH_test()
#undef  TEST_ADH_test

#define TEST_THIS(cond) testThis( cond, #cond, __FILE__, __LINE__ )

#define TEST_THIS_Msg(msg, cond) testThis( cond, msg, __FILE__, __LINE__ )

#define TEST_ERROR(str) recordError( str, __FILE__, __LINE__ )

#define TEST_SUCCESS() recordSuccess()

#define TEST_EQUAL(expected, actual) \
        testThis( (expected) == (actual), #expected " == " #actual, __FILE__, __LINE__ )

#define TEST_EQUAL_Msg(MSG, expected, actual) \
        testThis( (expected) == (actual), MSG, __FILE__, __LINE__ )

std::ostream & operator << (std::ostream& COUT, const TestCase& test) {
    COUT << "TestCase \""  << test.getName() << "\":\n"
         << "\tOK: "       << test.nPass()
         << "\tERROR: "    << test.nError() << "\n";
    return COUT;
}

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& ); 
inline bool check_ok( const signed char &   ) { return true; } 
inline bool check_ok( const unsigned char & ) { return true; } 
inline bool check_ok( const signed int &    ) { return true; } 
inline bool check_ok( const unsigned int&   ) { return true; } 
inline bool check_ok( const signed long &   ) { return true; } 
inline bool check_ok( const unsigned long & ) { return true; } 
inline bool check_ok( const float &         ) { return true; } 
inline bool check_ok( const double &        ) { return true; } 
inline bool check_ok( const long double &   ) { return true; } 

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( );
}

#define CPPUNIT_ADH_test()
#undef  CPPUNIT_ADH_test

#define CPPUNIT_ASSERT(condition) TEST_THIS(condition)

#define CPPUNIT_ASSERT_MESSAGE(message, condition) CPPUNIT_ASSERT(condition)

#define CPPUNIT_FAIL(message) TEST_ERROR(message)

#define CPPUNIT_ASSERT_EQUAL(expected, actual) TEST_EQUAL(expected, actual)

#define CPPUNIT_ASSERT_EQUAL_MESSAGE(message, expected, actual) \
        TEST_EQUAL_Msg(message, expected, actual)

#define CPPUNIT_ASSERT_DOUBLES_EQUAL(expected, actual, delta)                 \
        assertEquals_Delta(expected, actual, delta)

#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 )

#define CPPUNIT_ASSERT_NO_THROW(expression)                  \
        do {                                                 \
            try {                                            \
                expression;                                  \
            } catch ( ... ) {                                \
                TEST_ERROR("Unexpected exception caught");   \
            }                                                \
        } while ( false )

#define CPPUNIT_ASSERT_ASSERTION_FAIL(assertion)               \
        CPPUNIT_ASSERT_THROW( assertion, CPPUNIT_NS::Exception )

#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

#define assertEquals(          EXPECTED, ACTUAL ) TEST_EQUAL(EXPECTED, ACTUAL)
#define assertEquals_Msg( MSG, EXPECTED, ACTUAL ) TEST_EQUAL_Msg(MSG, EXPECTED, ACTUAL)

#define assertTrue(           CONDITION ) testThis( CONDITION, #CONDITION, __FILE__, __LINE__ )
#define assertTrue_Msg( MSG,  CONDITION ) testThis( CONDITION,  MSG,       __FILE__, __LINE__ )

#define assertFalse(          CONDITION ) testThis( !(CONDITION), "!(" #CONDITION ")", __FILE__, __LINE__ )
#define assertFalse_Msg( MSG, CONDITION ) testThis( !(CONDITION),       MSG,           __FILE__, __LINE__ )

#include <math.h> // fabs()
#define assertEquals_Delta(EXPECTED, ACTUAL, DELTA ) \
        testThis( fabs( double(EXPECTED) -  double(ACTUAL) ) < double(DELTA), \
        "|"  #EXPECTED "-" #ACTUAL "| < " #DELTA,  __FILE__, __LINE__ )

#define assertEquals_Delta_Msg( MSG, EXPECTED, ACTUAL, DELTA ) \
        testThis( fabs( double(EXPECTED) -  double(ACTUAL) ) < double(DELTA), \
        MSG, __FILE__, __LINE__ )

#define assertNull(OBJECT)    testThis( 0==&(OBJECT), "assertNull("    #OBJECT ")", __FILE__, __LINE__ )
#define assertNotNull(OBJECT) testThis( 0!=&(OBJECT), "assertNotNull(" #OBJECT ")", __FILE__, __LINE__ )

#define assertSame(THIS, THAT) testThis(    &(THIS)==&(THAT), "assertSame("    #THIS ", " #THAT ")", __FILE__, __LINE__ )
#define assertNotSame(THIS, THAT) testThis( &(THIS)!=&(THAT), "assertNotSame(" #THIS ", " #THAT ")", __FILE__, __LINE__ )

#define fail(     )     TEST_ERROR("ERROR")
#define fail_Msg( MSG ) TEST_ERROR(MSG)

#endif // ADH_test_h

// EOF: ADH_test.h

---

Hosted by www.Geocities.ws