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