TestCase.h

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; coding: iso-8859-1; -*-

/*
ACT-CV - Machine Vision for Cognitive Modeling
Copyright (c) 2008 Marc Halbruegge

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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#ifndef TESTCASE_H_
#define TESTCASE_H_

#include <iostream>
#include <vector>
#include <algorithm>
#include <garbagecoll.h>

namespace tests {

class TestCase;

class TestFailure {
public:
    GCPointer<TestCase> theTest;
    std::string theCause;
    
    std::string theFile;
    int theLine;
    
    TestFailure(const GCPointer<TestCase> &t, std::string cause) 
        : theTest(t), theCause(cause), theLine(-1) {}

    TestFailure(const GCPointer<TestCase> &t, std::string cause,
        std::string file, int line) 
        : theTest(t), theCause(cause), theFile(file), theLine(line) {}
};

class TestCase : virtual public ReferenceCount {
public:    
    template<class _t1, class _t2>
    void AssertEqual(_t1 a, _t2 b, const char *fn="", int l=-1) {
        if (! (a == b)) {
            throw TestFailure(this, "AssertEqual", fn, l);
        }
    }

    template<class _t1, class _t2>
    void AssertBelow(_t1 a, _t2 b, const char *fn="", int l=-1) {
        if (! (a < b)) {
            throw TestFailure(this, "AssertBelow", fn, l);
        }
    }

    template<class _t1, class _t2>
    void AssertAbove(_t1 a, _t2 b, const char *fn="", int l=-1) {
        if (! (a > b)) {
            throw TestFailure(this, "AssertAbove", fn, l);
        }
    }

    void AssertTrue(bool b, const char *fn="", int l=-1) {
        if (!b) throw TestFailure(this, "AssertTrue", fn, l);
    }
    void AssertFalse(bool b, const char *fn="", int l=-1) {
        if (b) throw TestFailure(this, "AssertFalse", fn, l);
    }

    virtual void Run() =0;
    virtual const char* GetName() const =0;
};

class TestSuite : public std::vector<GCPointer<TestCase> >, public TestCase {
    struct Tester {
        void operator () (GCPointer<TestCase> &t) {
            std::cout << t->GetName() << " ...";
            t->Run();
            std::cout << " success" << std::endl;
        }
    };
public:
    const char* GetName() const {
        return "TestSuite";
    }
    void Run() {
        std::for_each(begin(),end(),Tester());
    }
};  

}; // end of namespace tests

#endif /*TESTCASE_H_*/