tests/tut/tut_runner.hpp

   1 #ifndef TUT_RUNNER_H_GUARD
   2 #define TUT_RUNNER_H_GUARD
   3
   4 #include <string>
   5 #include <vector>
   6 #include <set>
   7 #include "tut_exception.hpp"
   8
   9 namespace tut
  10 {
  11
  12 /**
  13  * Interface.
  14  * Test group operations.
  15  */
  16 struct group_base
  17 {
  18     virtual ~group_base()
  19     {
  20     }
  21
  22     // execute tests iteratively
  23     virtual void rewind() = 0;
  24     virtual bool run_next(test_result &) = 0;
  25
  26     // execute one test
  27     virtual bool run_test(int n, test_result &tr) = 0;
  28 };
  29
  30
  31 /**
  32  * Test runner callback interface.
  33  * Can be implemented by caller to update
  34  * tests results in real-time. User can implement
  35  * any of callback methods, and leave unused
  36  * in default implementation.
  37  */
  38 struct callback
  39 {
  40     /**
  41      * Default constructor.
  42      */
  43     callback()
  44     {
  45     }
  46
  47     /**
  48      * Virtual destructor is a must for subclassed types.
  49      */
  50     virtual ~callback()
  51     {
  52     }
  53
  54     /**
  55      * Called when new test run started.
  56      */
  57     virtual void run_started()
  58     {
  59     }
  60
  61     /**
  62      * Called when a group started
  63      * @param name Name of the group
  64      */
  65     virtual void group_started(const std::string& name)
  66     {
  67         (void)name;
  68     }
  69
  70     /**
  71      * Called when a test finished.
  72      * @param tr Test results.
  73      */
  74     virtual void test_completed(const test_result& tr)
  75     {
  76         (void)tr;
  77     }
  78
  79     /**
  80      * Called when a group is completed
  81      * @param name Name of the group
  82      */
  83     virtual void group_completed(const std::string& name)
  84     {
  85         (void)name;
  86     }
  87
  88     /**
  89      * Called when all tests in run completed.
  90      */
  91     virtual void run_completed()
  92     {
  93     }
  94
  95     virtual bool all_ok() const
  96     {
  97         return true;
  98     }
  99 private:
 100     callback(const callback &);
 101     void operator=(const callback&);
 102 };
 103
 104 /**
 105  * Typedef for runner::list_groups()
 106  */
 107 typedef std::vector<std::string> groupnames;
 108 typedef std::set<callback*> callbacks;
 109
 110 /**
 111  * Test runner.
 112  */
 113 class test_runner
 114 {
 115
 116 public:
 117
 118     /**
 119      * Constructor
 120      */
 121     test_runner()
 122         : groups_(),
 123           callbacks_()
 124     {
 125     }
 126
 127     /**
 128      * Stores another group for getting by name.
 129      * @param name new group object
 130      * @param gr new callback object
 131      */
 132     void register_group(const std::string& name, group_base* gr)
 133     {
 134         if (gr == 0)
 135         {
 136             throw tut_error("group shall be non-null");
 137         }
 138
 139         if (groups_.find(name) != groups_.end())
 140         {
 141             std::string msg("attempt to add already existent group " + name);
 142             throw tut_error(msg);
 143         }
 144
 145         groups_.insert( std::make_pair(name, gr) );
 146     }
 147
 148     /**
 149      * Stores one callback object.
 150      * @param cb new callback object
 151      */
 152     void set_callback(callback *cb)
 153     {
 154         clear_callbacks();
 155         insert_callback(cb);
 156     }
 157
 158     /**
 159      * Add callback object.
 160      * @param cb new callback object
 161      */
 162     void insert_callback(callback* cb)
 163     {
 164         if(cb != NULL)
 165         {
 166             callbacks_.insert(cb);
 167         }
 168     }
 169
 170     /**
 171      * Remove callback object.
 172      * @param cb callback to remove
 173      */
 174     void erase_callback(callback* cb)
 175     {
 176         callbacks_.erase(cb);
 177     }
 178
 179     /**
 180      * Remove all callback objects.
 181      */
 182     void clear_callbacks()
 183     {
 184         callbacks_.clear();
 185     }
 186
 187     /**
 188      * Returns callback list.
 189      * @return     callback list
 190      */
 191     const callbacks &get_callbacks() const
 192     {
 193         return callbacks_;
 194     }
 195
 196     /**
 197      * Set callback list.
 198      * @param cb new callback list
 199      */
 200     void set_callbacks(const callbacks &cb)
 201     {
 202         callbacks_ = cb;
 203     }
 204
 205     /**
 206      * Returns list of known test groups.
 207      * @return     groups list
 208      */
 209     const groupnames list_groups() const
 210     {
 211         groupnames ret;
 212         for(const_iterator i = groups_.begin(); i != groups_.end(); ++i)
 213         {
 214             ret.push_back(i->first);
 215         }
 216         return ret;
 217     }
 218
 219     /**
 220      * Runs all tests in all groups.
 221      */
 222     void run_tests() const
 223     {
 224         cb_run_started_();
 225
 226         const_iterator i = groups_.begin();
 227         const_iterator e = groups_.end();
 228         while (i != e)
 229         {
 230             cb_group_started_(i->first);
 231             run_all_tests_in_group_(i);
 232             cb_group_completed_(i->first);
 233
 234             ++i;
 235         }
 236
 237         cb_run_completed_();
 238     }
 239
 240     /**
 241      * Runs all tests in specified group.
 242      * @param group_name group to test
 243      */
 244     void run_tests(const std::string& group_name) const
 245     {
 246         cb_run_started_();
 247
 248         const_iterator i = groups_.find(group_name);
 249         if (i == groups_.end())
 250         {
 251             cb_run_completed_();
 252             throw no_such_group(group_name);
 253         }
 254
 255         cb_group_started_(group_name);
 256         run_all_tests_in_group_(i);
 257         cb_group_completed_(group_name);
 258         cb_run_completed_();
 259     }
 260
 261     /**
 262      * Runs one test in specified group.
 263      * @param group_name group to test
 264      * @param n run case in test
 265      * @param tr result of this case
 266      * @return  true if test is ok, otherwise false
 267      */
 268     bool run_test(const std::string& group_name, int n, test_result &tr) const
 269     {
 270         cb_run_started_();
 271
 272         const_iterator i = groups_.find(group_name);
 273         if (i == groups_.end())
 274         {
 275             cb_run_completed_();
 276             throw no_such_group(group_name);
 277         }
 278
 279         cb_group_started_(group_name);
 280
 281         bool t = i->second->run_test(n, tr);
 282
 283         if(t && tr.result != test_result::dummy)
 284         {
 285             cb_test_completed_(tr);
 286         }
 287
 288         cb_group_completed_(group_name);
 289         cb_run_completed_();
 290
 291         return t;
 292     }
 293
 294 protected:
 295
 296     typedef std::map<std::string, group_base*> groups;
 297     typedef groups::iterator iterator;
 298     typedef groups::const_iterator const_iterator;
 299     groups groups_;
 300
 301     callbacks callbacks_;
 302
 303 private:
 304     friend class restartable_wrapper;
 305
 306     void cb_run_started_() const
 307     {
 308         for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
 309         {
 310             (*i)->run_started();
 311         }
 312     }
 313
 314     void cb_run_completed_() const
 315     {
 316         for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
 317         {
 318             (*i)->run_completed();
 319         }
 320     }
 321
 322     void cb_group_started_(const std::string &group_name) const
 323     {
 324         for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
 325         {
 326             (*i)->group_started(group_name);
 327         }
 328     }
 329
 330     void cb_group_completed_(const std::string &group_name) const
 331     {
 332         for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
 333         {
 334             (*i)->group_completed(group_name);
 335         }
 336     }
 337
 338     void cb_test_completed_(const test_result &tr) const
 339     {
 340         for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
 341         {
 342             (*i)->test_completed(tr);
 343         }
 344     }
 345
 346     void run_all_tests_in_group_(const_iterator i) const
 347     {
 348         i->second->rewind();
 349
 350         test_result tr;
 351         while(i->second->run_next(tr))
 352         {
 353             if(tr.result != test_result::dummy)
 354             {
 355                 cb_test_completed_(tr);
 356             }
 357
 358             if (tr.result == test_result::ex_ctor)
 359             {
 360                 // test object ctor failed, skip whole group
 361                 break;
 362             }
 363         }
 364     }
 365 };
 366
 367 /**
 368  * Singleton for test_runner implementation.
 369  * Instance with name runner_singleton shall be implemented
 370  * by user.
 371  */
 372 class test_runner_singleton
 373 {
 374 public:
 375
 376     static test_runner& get()
 377     {
 378         static test_runner tr;
 379         return tr;
 380     }
 381 };
 382
 383 extern test_runner_singleton runner;
 384
 385 }
 386
 387 #endif // TUT_RUNNER_H_GUARD
 388