tut_runner.hpp

#ifndef TUT_RUNNER_H_GUARD
#define TUT_RUNNER_H_GUARD

#include <string>
#include <vector>
#include <set>
#include "tut_exception.hpp"

namespace tut
{

struct group_base
{
    virtual ~group_base()
    {
    }

    // execute tests iteratively
    virtual void rewind() = 0;
    virtual bool run_next(test_result &) = 0;

    // execute one test
    virtual bool run_test(int n, test_result &tr) = 0;
};


struct callback
{
    callback()
    {
    }

    virtual ~callback()
    {
    }

    virtual void run_started()
    {
    }

    virtual void group_started(const std::string& name)
    {
        (void)name;
    }

    virtual void test_completed(const test_result& tr)
    {
        (void)tr;
    }

    virtual void group_completed(const std::string& name)
    {
        (void)name;
    }

    virtual void run_completed()
    {
    }

    virtual bool all_ok() const
    {
        return true;
    }
private:
    callback(const callback &);
    void operator=(const callback&);
};

typedef std::vector<std::string> groupnames;
typedef std::set<callback*> callbacks;

class test_runner
{

public:

    test_runner()
        : groups_(),
          callbacks_()
    {
    }

    void register_group(const std::string& name, group_base* gr)
    {
        if (gr == 0)
        {
            throw tut_error("group shall be non-null");
        }

        if (groups_.find(name) != groups_.end())
        {
            std::string msg("attempt to add already existent group " + name);
            throw tut_error(msg);
        }

        groups_.insert( std::make_pair(name, gr) );
    }

    void set_callback(callback *cb)
    {
        clear_callbacks();
        insert_callback(cb);
    }

    void insert_callback(callback* cb)
    {
        if(cb != NULL)
        {
            callbacks_.insert(cb);
        }
    }

    void erase_callback(callback* cb)
    {
        callbacks_.erase(cb);
    }

    void clear_callbacks()
    {
        callbacks_.clear();
    }

    const callbacks &get_callbacks() const
    {
        return callbacks_;
    }

    void set_callbacks(const callbacks &cb)
    {
        callbacks_ = cb;
    }

    const groupnames list_groups() const
    {
        groupnames ret;
        for(const_iterator i = groups_.begin(); i != groups_.end(); ++i)
        {
            ret.push_back(i->first);
        }
        return ret;
    }

    void run_tests() const
    {
        cb_run_started_();

        const_iterator i = groups_.begin();
        const_iterator e = groups_.end();
        while (i != e)
        {
            cb_group_started_(i->first);
            run_all_tests_in_group_(i);
            cb_group_completed_(i->first);

            ++i;
        }

        cb_run_completed_();
    }

    void run_tests(const std::string& group_name) const
    {
        cb_run_started_();

        const_iterator i = groups_.find(group_name);
        if (i == groups_.end())
        {
            cb_run_completed_();
            throw no_such_group(group_name);
        }

        cb_group_started_(group_name);
        run_all_tests_in_group_(i);
        cb_group_completed_(group_name);
        cb_run_completed_();
    }

    bool run_test(const std::string& group_name, int n, test_result &tr) const
    {
        cb_run_started_();

        const_iterator i = groups_.find(group_name);
        if (i == groups_.end())
        {
            cb_run_completed_();
            throw no_such_group(group_name);
        }

        cb_group_started_(group_name);

        bool t = i->second->run_test(n, tr);

        if(t && tr.result != test_result::dummy)
        {
            cb_test_completed_(tr);
        }

        cb_group_completed_(group_name);
        cb_run_completed_();

        return t;
    }

protected:

    typedef std::map<std::string, group_base*> groups;
    typedef groups::iterator iterator;
    typedef groups::const_iterator const_iterator;
    groups groups_;

    callbacks callbacks_;

private:
    friend class restartable_wrapper;

    void cb_run_started_() const
    {
        for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
        {
            (*i)->run_started();
        }
    }

    void cb_run_completed_() const
    {
        for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
        {
            (*i)->run_completed();
        }
    }

    void cb_group_started_(const std::string &group_name) const
    {
        for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
        {
            (*i)->group_started(group_name);
        }
    }

    void cb_group_completed_(const std::string &group_name) const
    {
        for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
        {
            (*i)->group_completed(group_name);
        }
    }

    void cb_test_completed_(const test_result &tr) const
    {
        for(callbacks::const_iterator i = callbacks_.begin(); i != callbacks_.end(); ++i)
        {
            (*i)->test_completed(tr);
        }
    }

    void run_all_tests_in_group_(const_iterator i) const
    {
        i->second->rewind();

        test_result tr;
        while(i->second->run_next(tr))
        {
            if(tr.result != test_result::dummy)
            {
                cb_test_completed_(tr);
            }

            if (tr.result == test_result::ex_ctor)
            {
                // test object ctor failed, skip whole group
                break;
            }
        }
    }
};

class test_runner_singleton
{
public:

    static test_runner& get()
    {
        static test_runner tr;
        return tr;
    }
};

extern test_runner_singleton runner;

}

#endif // TUT_RUNNER_H_GUARD