cppu.h

   1 #ifndef _CPPU_H_
   2 #define _CPPU_H_
   3
   4 #include <string>
   5 #include <vector>
   6 /**
   7  * TODO: Copyright, license...
   8  * TODO: Udelat to tak, aby se vse vypisovalo za behu a nemuselo se cekat
   9  * na dobehnuti celeho testu
  10  *
  11  * TODO: Dopsat vsechny aserce
  12  *
  13  * TODO: Zaradit do vypisu chyby take nazev test case?
  14  */
  15
  16 /**
  17  * Struct describing error message.
  18  */
  19 struct error_message_t{
  20     std::string file;
  21     int line;
  22     std::string message;
  23 };
  24
  25 /**
  26  * Struct describing state after run test.
  27  */
  28 struct test_state_t{
  29     std::string test_name; // name of test
  30     int assertations; // num of assertations
  31     int fails; // num of failed assertations
  32     int successes; // num of succeed assertations
  33     std::vector<error_message_t> error_messages; // list of error messages
  34
  35     inline void clean(void){assertations=0;fails=0;successes=0;error_messages.clear();}
  36 };
  37
  38
  39 /**
  40  * Abstract base class.
  41  * This defines the base methods which must have all classes which handle
  42  * any tests, test cases and so on.
  43  * Because of this class it's possible to register test suite into other
  44  * test suite.
  45  */
  46 class TestBase{
  47   protected:
  48     const std::string _name;
  49
  50     TestBase(const std::string n) : _name(n){}
  51   public:
  52     virtual ~TestBase(){}
  53     virtual void run(bool verbose) = 0;
  54
  55     /**
  56      * This two functions determines whether class is TestCase or
  57      * TestSuite.
  58      */
  59     virtual bool isTestCase() const = 0;
  60     virtual bool isTestSuite() const = 0;
  61
  62     /**
  63      * Inherited class must redefine only these methods which make sense
  64      * for them.
  65      */
  66     virtual int assertations() const { return 0;}
  67     virtual int assertationsFailed() const { return 0;}
  68     virtual int assertationsSucceed() const { return 0;}
  69     virtual int testSuites() const { return 0;}
  70     virtual int testSuitesFailed() const { return 0;}
  71     virtual int testSuitesSucceed() const { return 0;}
  72     virtual int testCases() const { return 0;}
  73     virtual int testCasesFailed() const { return 0;}
  74     virtual int testCasesSucceed() const { return 0;}
  75     virtual int tests() const { return 0;}
  76     virtual int testsFailed() const { return 0;}
  77     virtual int testsSucceed() const { return 0;}
  78
  79     virtual void printSummary(std::ostream &out = std::cout) const;
  80 };
  81
  82
  83
  84 /**
  85  * Main test case class.
  86  * This class collects all individual tests in one test case.
  87  */
  88 class TestCase : public TestBase{
  89   protected:
  90     int _tests;
  91     int _fails;
  92     int _successes;
  93
  94     /**
  95      * List of states of all ran tests.
  96      */
  97     std::vector<test_state_t> _tests_states;
  98
  99     /**
 100      * State of currently running test.
 101      * This struct must be empty before running next test method.
 102      */
 103     test_state_t _current_test;
 104
 105     /**
 106      * Indicates if current running test case has to be verbose
 107      */
 108     bool _verbose;
 109
 110
 111     /**
 112      * Returns formated error message
 113      */
 114     std::string _getErrorMessage(const std::string file, const int line,
 115             const std::string test_method,
 116             const std::string error_message) const;
 117
 118
 119     /**
 120      * Usage:
 121      *      _prepareTest("nameOfTheTest");
 122      *      testMethod();
 123      *      _finishTest();
 124      */
 125     void _prepareTest(std::string test_name);
 126     void _finishTest();
 127
 128     /**
 129      * Record assertation as succeed
 130      */
 131     void _successAssertation();
 132
 133     /**
 134      * Record assertations as failed and print error message to stdout (if
 135      * verbose set)
 136      */
 137     void _failAssertation(std::string file, int line,
 138             std::string error_message);
 139
 140     /**
 141      * Constructor is protected because new test case (which inherits from
 142      * TestCase class) only defines its own constructor which only call
 143      * this one with its name as argument.
 144      */
 145     explicit TestCase(const std::string& n) : TestBase(n), _tests(0),
 146             _fails(0), _successes(0), _verbose(false){}
 147   public:
 148     virtual ~TestCase(){}
 149
 150     bool isTestCase() const { return true;}
 151     bool isTestSuite() const { return false;}
 152
 153     virtual void setUp(){}
 154     virtual void tearDown(){}
 155
 156     /**
 157      * Method describing tests.
 158      * This must be redefined in extended class.
 159      */
 160     virtual void runTests() = 0;
 161
 162     /**
 163      * This run the test case.
 164      * If verbose is set to true, errors will be printed during
 165      * test case running.
 166      * Returns number of failed tests or 255 (lesser number)
 167      */
 168     void run(bool verbose = false);
 169
 170
 171     int assertations() const;
 172     int assertationsFailed() const;
 173     int assertationsSucceed() const;
 174     int tests() const {return _tests;}
 175     int testsFailed() const {return _fails;}
 176     int testsSucceed() const {return _successes;}
 177
 178     /**
 179      * Print error messages into given stream
 180      */
 181     void errorMessages(std::ostream &out = std::cout) const;
 182 };
 183
 184
 185
 186 /**
 187  * Main test suite class.
 188  * This class collect all test cases and run them together.
 189  * TestSuite can collect and mix test cases and other test suites together,
 190  * so it's possible to create hirearchy of tests.
 191  * Test cases and test suites are run in order they are registered.
 192  */
 193 class TestSuite : public TestBase{
 194     std::vector<TestBase *> tests;
 195
 196   public:
 197     TestSuite(const std::string& n) : TestBase(n){}
 198     virtual ~TestSuite();
 199
 200     bool isTestCase() const { return false;}
 201     bool isTestSuite() const { return true;}
 202
 203     /**
 204      * Register test cases and test suites for later run.
 205      */
 206     void reg(TestBase *tc){ tests.push_back(tc); }
 207
 208     /**
 209      * Run all test cases.
 210      */
 211     void run(bool verbose);
 212 };
 213
 214
 215 /***** TestCase MACROS *****/
 216 #define TEST_CASE(name) \
 217     class name : public TestCase{ \
 218       public: \
 219         name() : TestCase(#name){}
 220
 221 #define TEST_CASE_END };
 222
 223 #define TESTS void runTests()
 224
 225 #define TEST(test_name) \
 226     _prepareTest(#test_name); \
 227     this->test_name(); \
 228     _finishTest();
 229
 230
 231
 232 #define assertTrueM(a, message) \
 233     if (a){ \
 234         _successAssertation(); \
 235     }else{ \
 236         _failAssertation(__FILE__, __LINE__, message); \
 237     }
 238 #define assertTrue(a) \
 239     assertTrueM((a), #a " is not true")
 240
 241 #define assertFalseM(a, message) \
 242     assertTrueM(!(a), message)
 243 #define assertFalse(a) \
 244     assertFalseM((a), #a " is not false")
 245
 246 #define assertEqualsM(a,b,message) \
 247     assertTrueM((a) == (b), message)
 248 #define assertEquals(a,b) \
 249     assertEqualsM((a), (b), #a " not equals " #b)
 250
 251 #define assertNotEqualsM(a,b,message) \
 252     assertTrueM((a) != (b), message)
 253 #define assertNotEquals(a,b) \
 254     assertNotEqualsM((a), (b), #a " equals " #b)
 255 #endif
 256 /* vim: set sw=4 ts=4 et ft=cpp tw=75 cindent: */