test/cutee.h

   1 /***************************************************************************
   2     copyright            : (C) 2003-2005 by Stefano Barbato
   3     email                : stefano@codesink.org
   4
   5     $Id: cutee.h,v 1.14 2008-10-07 15:43:55 tat Exp $
   6  ***************************************************************************/
   7
   8 /***************************************************************************
   9  *                                                                         *
  10  *   This program is free software; you can redistribute it and/or modify  *
  11  *   it under the terms of the GNU General Public License as published by  *
  12  *   the Free Software Foundation; either version 2 of the License, or     *
  13  *   (at your option) any later version.                                   *
  14  *                                                                         *
  15  ***************************************************************************/
  16
  17 #ifndef _CUTEE_CUTEE_H_
  18 #define _CUTEE_CUTEE_H_
  19 #include <cstdlib>
  20 #include <iostream>
  21 #include <sstream>
  22 #include <iomanip>
  23 #include <stdarg.h>
  24
  25 typedef unsigned int uint;
  26
  27 #define CUTEE_VERSION "0.4.2"
  28
  29 #define MAX_TEST_COUNT 1000
  30
  31
  32 #define TEST_CLASS( name ) \
  33     dummy_##name: public cutee::CuteeTest { \
  34     public: \
  35         dummy_##name() \
  36         { \
  37             className(#name); \
  38             classFileName(__FILE__); \
  39             classLineNo(__LINE__); \
  40         } \
  41     }; \
  42     struct name: public dummy_##name
  43 #define TEST_FUNCTION_EX( funcname, filename, lineno ) \
  44     run_##funcname() \
  45     { \
  46         functionName(#funcname); \
  47         functionLineNo(lineno); \
  48         mEvt->enterFunction(*this); \
  49         mFuncExitCode = 0; \
  50         funcname(); \
  51         if(mFuncExitCode) mFailed++; \
  52         mEvt->leaveFunction(*this, mFuncExitCode == 0); \
  53     } \
  54     void funcname()
  55
  56
  57 #define TEST_FUNCTION( funcname ) \
  58     TEST_FUNCTION_EX( funcname, __FILE__, __LINE__)
  59
  60 #define PRINT_VALUE( a ) \
  61     "\t[" << #a << ": " << a << "]" << std::endl
  62
  63 #define PRINT_ON_FAILURE_1( a ) \
  64     PRINT_VALUE( a )
  65 #define PRINT_ON_FAILURE_2( a, b ) \
  66     PRINT_VALUE( a ) << PRINT_VALUE( b )
  67 #define PRINT_ON_FAILURE_3( a, b, c ) \
  68     PRINT_VALUE( a ) << PRINT_VALUE( b ) << PRINT_VALUE( c )
  69 #define PRINT_ON_FAILURE_4( a, b, c, d ) \
  70     PRINT_VALUE( a ) << PRINT_VALUE( b ) << \
  71     PRINT_VALUE( c ) << PRINT_VALUE( d )
  72
  73 #define TEST_ASSERT_EX( e, file, line ) \
  74     do { expr(#e); exprFileName(file); exprLineNo(line); \
  75     testAssert(e); } while(0)
  76
  77 #define TEST_ASSERT_EX_M( e, p, file, line ) \
  78     do { expr(#e); exprFileName(file); exprLineNo(line); \
  79     std::stringstream _l_ss; _l_ss << p << std::endl; \
  80     testAssertM(e, _l_ss ); } while(0)
  81
  82
  83
  84 #define TEST_ASSERT( expr ) TEST_ASSERT_EX( expr, __FILE__, __LINE__ )
  85 #define TEST_ASSERT_EQUALS( a, b ) TEST_ASSERT_EX( (a == b), __FILE__,__LINE__ )
  86 #define TEST_ASSERT_DIFFERS( a, b ) TEST_ASSERT_EX( (a != b),__FILE__,__LINE__ )
  87
  88 // print p on test fail
  89 #define TEST_ASSERT_M( expr , p) TEST_ASSERT_EX_M( expr, p, __FILE__,__LINE__ )
  90 #define TEST_ASSERT_EQUALS_M( a, b, p ) TEST_ASSERT_EX_M( (a == b), p,__FILE__,__LINE__ )
  91 #define TEST_ASSERT_DIFFERS_M( a, b, p ) TEST_ASSERT_EX_M( (a != b), p,__FILE__,__LINE__)
  92
  93 // print a and b on error
  94 #define TEST_ASSERT_P( expr ) TEST_ASSERT_EX_M( expr, PRINT_ON_FAILURE_1( expr ), __FILE__,__LINE__ )
  95 #define TEST_ASSERT_EQUALS_P( a, b ) TEST_ASSERT_EX_M( (a == b), PRINT_ON_FAILURE_2( a, b ), __FILE__,__LINE__ )
  96 #define TEST_ASSERT_DIFFERS_P( a, b ) TEST_ASSERT_EX_M( (a != b), PRINT_ON_FAILURE_2( a, b ), __FILE__,__LINE__)
  97
  98 #define TEST_ASSERT_PM( expr, m ) TEST_ASSERT_EX_M( expr, PRINT_ON_FAILURE_2( expr, m ), __FILE__,__LINE__ )
  99 #define TEST_ASSERT_EQUALS_PM( a, b, m ) TEST_ASSERT_EX_M( (a == b), PRINT_ON_FAILURE_3( a, b, m ), __FILE__,__LINE__ )
 100 #define TEST_ASSERT_DIFFERS_PM( a, b, m ) TEST_ASSERT_EX_M( (a != b), PRINT_ON_FAILURE_3( a, b, m ), __FILE__,__LINE__)
 101
 102 #define TEST_ASSERT_OR_RET(expr, msg) \
 103     do { if(!expr) { TEST_ASSERT_M(expr, msg); return; } } while(0)
 104
 105
 106 namespace cutee // c++ unit testing environment
 107 {
 108
 109 struct CuteeTest;
 110
 111 // store runtime context (class name, function name, line numbers, etc.)
 112 struct Context
 113 {
 114     typedef std::string string;
 115     Context()
 116     : mClassLineNo(0), mFunctionLineNo(0), mExprLineNo(0)
 117     {}
 118     // class info
 119     const string& className() const    { return mClassName; }
 120     uint classLineNo() const { return mClassLineNo; }
 121     const string& classFileName() const { return mClassFileName; }
 122     // filename
 123     const string& fileName() const { return mFileName; }
 124     // function info
 125     const string& functionName() const { return mFunctionName; }
 126     uint functionLineNo() const { return mFunctionLineNo; }
 127     // assertion info
 128     const string& expr() const { return mExpr; }
 129     const string& exprFileName() const { return mExprFileName; }
 130     uint exprLineNo() const { return mExprLineNo; }
 131
 132     void className(const string& s) { mClassName = s; }
 133     void classFileName(const string& s) { mClassFileName = s; }
 134     void classLineNo(uint i) { mClassLineNo = i; }
 135
 136     void filename(const string& s) { mFileName = s; }
 137
 138     void functionName(const string& s) { mFunctionName = s; }
 139     void functionLineNo(uint i) { mFunctionLineNo = i; }
 140
 141     void expr(const string& s) { mExpr = s; }
 142     void exprFileName(const string& s) { mExprFileName = s; }
 143     void exprLineNo(uint i) { mExprLineNo = i; }
 144 private:
 145     std::string mClassName, mClassFileName, mFunctionName,
 146         mFileName, mExpr, mExprFileName;
 147     uint mClassLineNo, mFunctionLineNo, mExprLineNo;
 148 };
 149
 150
 151 // execution monitor interface
 152 struct TestRunMonitor
 153 {
 154     virtual ~TestRunMonitor() {}
 155
 156     virtual void beginTesting() {}
 157     virtual void endTesting() {}
 158
 159     // virtual void enterSuite(const CuteeTest&) {}
 160     // virtual void leaveSuite(const CuteeTest&, int b) {}
 161
 162     virtual void enterClass(const CuteeTest&) {}
 163     virtual void leaveClass(const CuteeTest&, int) {}
 164
 165     virtual void enterFunction(const CuteeTest&) {}
 166     virtual void leaveFunction(const CuteeTest&, int ) {}
 167
 168     virtual void assertion(const CuteeTest&, int,
 169         const std::string& u = "") {}
 170 };
 171
 172 // statically store pointers to test classes
 173 struct TestList
 174 {
 175     virtual ~TestList() {}
 176     // FIXME add dynamic array alloc to avoid fixed limit
 177     static CuteeTest* list[MAX_TEST_COUNT];
 178     static int list_idx;
 179 };
 180
 181
 182
 183 // this is the base class of all cutee test classes
 184 struct CuteeTest: public cutee::Context
 185 {
 186     CuteeTest()
 187     : mEvt(&mNullMonitor), mFuncExitCode(0), mFailed(0)
 188     {
 189     }
 190     virtual ~CuteeTest() {}
 191     virtual void setUp() {}
 192     virtual void tearDown()    {}
 193     void testRunMonitor(TestRunMonitor *evt) { mEvt = evt; }
 194     int passed() const  { return mFailed == 0; }
 195     virtual void run() = 0;
 196     virtual uint count() = 0;
 197 protected:
 198     void testAssert(int b)
 199     {
 200         if( b == 0 ) // assertion failed
 201             mFuncExitCode++;
 202         mEvt->assertion(*this, b);
 203     }
 204     void testAssertM(int b, std::stringstream& os)
 205     {
 206         if( b == 0 ) // assertion failed
 207             mFuncExitCode++;
 208         mEvt->assertion(*this, b, os.str());
 209     }
 210 protected:
 211     TestRunMonitor *mEvt, mNullMonitor;
 212     uint mFuncExitCode, mFailed;
 213 };
 214
 215
 216
 217 // monitors execution and keep statistics on classes/functions/tests
 218 struct StatsMonitor: public TestRunMonitor
 219 {
 220     StatsMonitor()
 221     : mAssertPassed(0), mAssertFailed(0), mAssertCount(0),
 222       mFuncPassed(0),  mFuncFailed(0), mFuncCount(0),
 223       mClassPassed(0),  mClassFailed(0), mClassCount(0)
 224     {
 225     }
 226     // void enterSuite(const CuteeTest& t)    {}
 227     // void leaveSuite(const CuteeTest& t, int b) {}
 228     void enterClass(const CuteeTest& t)
 229     {
 230         mClassCount++;
 231     }
 232     void leaveClass(const CuteeTest& t, int b)
 233     {
 234         if(b)
 235             mClassPassed++;
 236         else
 237             mClassFailed++;
 238     }
 239     void enterFunction(const CuteeTest&)
 240     {
 241         mFuncCount++;
 242     }
 243     void leaveFunction(const CuteeTest&, int b)
 244     {
 245         if(b)
 246             mFuncPassed++;
 247         else
 248             mFuncFailed++;
 249     }
 250     void assertion(const CuteeTest& t, int b, const std::string& userMsg)
 251     {
 252         mAssertCount++;
 253         if(b)
 254             mAssertPassed++;
 255         else
 256             mAssertFailed++;
 257     }
 258 protected:
 259     uint mAssertPassed, mAssertFailed, mAssertCount, mFuncPassed,
 260          mFuncFailed, mFuncCount, mClassPassed, mClassFailed, mClassCount;
 261 };
 262
 263 // keep stats and print results on exit
 264 struct ConsoleRunMonitor: public StatsMonitor
 265 {
 266     void assertion(const CuteeTest& t, int b, const std::string& userMsg)
 267     {
 268         using namespace std;
 269         StatsMonitor::assertion(t, b, userMsg);
 270         if(!b)
 271         {
 272             cout << endl << " ["
 273                 << t.exprFileName() << ":"
 274                 << t.exprLineNo()<< "] "
 275                 << t.className() << "::"
 276                 << t.functionName() << "(): "
 277                 << t.expr() << " assertion failed"
 278                 << endl;
 279             if(!userMsg.empty())
 280                 cout << userMsg << endl;
 281         }
 282     }
 283     void endTesting()
 284     {
 285         using namespace std;
 286         cout << endl << endl;
 287         cout << "    ======================================" << endl;
 288         cout << "          Tests Statistics           " << endl;
 289         cout << "    --------------------------------------" << endl;
 290         cout << "                Functions       Checks   " << endl;
 291         cout << "      Success   "<< setw(8) << mFuncPassed <<
 292             "      " << setw(8) << mAssertPassed << endl;
 293         cout << "       Failed   "<< setw(8) << mFuncFailed <<
 294             "      " << setw(8) << mAssertFailed << endl;
 295         cout << "    --------------------------------------" << endl;
 296         cout << "        Total   "<< setw(8) << mFuncCount <<
 297             "      " <<  setw(8) << mAssertCount << endl;
 298         cout << "    ======================================" << endl;
 299     }
 300 };
 301
 302 // keep stats and print skimmer xml output on exit
 303 struct SkimmerRunMonitor: public StatsMonitor
 304 {
 305     void beginTesting()
 306     {
 307         using namespace std;
 308         cout << "<?xml version=\"1.0\"?>" << endl;
 309         cout << "<tests>" << endl;
 310     }
 311     void endTesting()
 312     {
 313         using namespace std;
 314         cout << "</tests>" << endl;
 315     }
 316     void enterClass(const CuteeTest&)
 317     {
 318     }
 319     void leaveClass(const CuteeTest&, int)
 320     {
 321     }
 322     void enterFunction(const CuteeTest& t)
 323     {
 324         using namespace std;
 325         cout << "<test>" << endl;
 326         cout << "<name>";
 327         cout << t.className() << "::" << t.functionName() << "()";
 328         cout << "</name>" << endl;
 329     }
 330     void leaveFunction(const CuteeTest& t, int b)
 331     {
 332         using namespace std;
 333         cout << "<type>" << (b ? "pass" : "fail") << "</type>" << endl;
 334         cout << "</test>" << endl << endl << endl;
 335     }
 336     void assertion(const CuteeTest& t, int b, const std::string& u = "")
 337     {
 338         using namespace std;
 339         if(b)
 340             return;
 341         cout << "  <info>" << endl;
 342         cout << "  <type>" << (b ? "pass" : "fail") << "</type>" << endl;
 343         cout << "  <data>" << endl;
 344         cout << "  <file>" << t.exprFileName() << "</file>" << endl;
 345         cout << "  <line>" << t.exprLineNo() << "</line>" << endl;
 346         cout << "  <expression>" << t.expr() << "</expression>" <<endl;
 347         if(!u.empty())
 348             cout << "  <output>" << u << endl << "  </output>" << endl;
 349         cout << "  </expression>" << endl;
 350         cout << "  </data>" << endl;
 351         cout << "  </info>" << endl << endl;
 352     }
 353 };
 354
 355 // create the appropriate TestRunMonitor based on environment variables
 356 // or command line parameters and run tests
 357 struct Runner
 358 {
 359     Runner(int argc, char** argv)
 360     : mEvt(0)
 361     {
 362         if(getenv("SKIMMER_MODE"))
 363             mEvt = new SkimmerRunMonitor;
 364         else
 365             mEvt = new ConsoleRunMonitor;
 366     }
 367     void run()
 368     {
 369         mEvt->beginTesting();
 370         for(int i =0; i < TestList::list_idx; i++)
 371         {
 372             CuteeTest *ct = TestList::list[i];
 373             ct->testRunMonitor(mEvt);
 374             mEvt->enterClass(*ct);
 375             ct->run();
 376             mEvt->leaveClass(*ct, ct->passed());
 377         }
 378         mEvt->endTesting();
 379     }
 380 private:
 381     TestRunMonitor *mEvt;
 382 };
 383
 384 }
 385
 386
 387 #endif