unittest_decls.h

/*
 *  Copyright (C) 2006  Helmut Grohne
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef LIBMUTH_UNITTEST_DECLS_H
#define LIBMUTH_UNITTEST_DECLS_H

#include <list>
#include <memory>
#include <stdexcept>
#include <string>

class Fixture {
        public:
                virtual ~Fixture();
};

class BaseGatherer {
        public:
                virtual std::auto_ptr<BaseGatherer> clone()=0;
                virtual void succeed(const std::string &n)=0;
                virtual void fail(const std::string &n, const std::string &r)=0;
                virtual void pending(int n=1);
                virtual BaseGatherer &forwardto();
                virtual const std::string &prefixed() const;
                virtual ~BaseGatherer();
};

class ForwardGatherer : public BaseGatherer {
        private:
                BaseGatherer &gatherer;
                std::string prefix;
        public:
                std::auto_ptr<BaseGatherer> clone();
                ForwardGatherer(BaseGatherer &g, const std::string &p);
                void succeed(const std::string &n);
                void fail(const std::string &n, const std::string &r);
                void pending(int n);
                BaseGatherer &forwardto();
                const std::string &prefixed() const;
};

class Gatherer : public BaseGatherer {
        private:
                int succeeded;
                int failed;
        public:
                Gatherer();
                std::auto_ptr<BaseGatherer> clone();
                void succeed(const std::string &n);
                void fail(const std::string &n, const std::string &r);
                void stats();
                int failed_tests();
};

class BaseTest {
        protected:
                std::string name;
        public:
                BaseTest(const std::string &n);
                virtual BaseTest *clone() const=0;
                virtual void run(BaseGatherer &g)=0;
                virtual ~BaseTest();
};

template<class F> class TestCase : public BaseTest {
        private:
                void (F::*function)();
        public:
                TestCase(const std::string &n, void (F::*func)());
                TestCase(const TestCase &other);
                TestCase<F> *clone() const;
                void run(BaseGatherer &g);
};

class TestSuite : public BaseTest {
        private:
                std::list<BaseTest*> tests;
        public:
                TestSuite(const std::string &n);
                TestSuite(const TestSuite &o);
                TestSuite *clone() const;
                void addtest(BaseTest *test);
                void run(BaseGatherer &g);
                ~TestSuite();
};

class Failure : public std::runtime_error {
        public:
                Failure(const std::string &r);
};

void unittest_assert(bool test, const std::string &r);

void unittest_run(BaseTest *t, BaseGatherer &g);

void unittest_main(std::auto_ptr<BaseTest> t);

#endif

---