TestSuiteTyped.h

Go to the documentation of this file.

#ifndef JON_TEST_TEST_SUITE_TYPED_H
#define JON_TEST_TEST_SUITE_TYPED_H
 
#include "JonTest/Count.h"
#include "JonTest/Logger.h"
#include "JonTest/TestCase.h"
#include "JonTest/TestRunner.h"
#include "JonTest/TestSuiteInterface.h"
 
#include <algorithm>
#include <map>
#include <string>
#include <vector>
 
namespace JonTest
{
 
template <typename TestSuiteDerived>
class TestSuiteTyped : public TestSuiteInterface
{
public:
    typedef TestSuiteDerived TestSuite;
 
    typedef void (TestSuite::*TestCaseMethod)();
 
private:
    const std::string suiteName;
 
    std::map<std::string, TestCase<TestSuite>> cases;
 
protected:
    TestSuiteTyped(
        const char * const suiteName 
    )
    : suiteName(suiteName)
    {
        TestRunner::get().add(suiteName, this);
    }
 
    virtual ~TestSuiteTyped() { }
 
public:
    const std::string& 
    getName() const {
        return suiteName;
    }
 
    virtual bool 
    isValid(
        const std::string& caseName
    ) const
    {
        return cases.end() != cases.find(caseName);
    }
 
    void add(
        const char* const testCaseName, 
        TestCaseMethod const testCaseMethod 
    )
    {
        // \todo Error check for overwrite
        cases[testCaseName] = TestCase<TestSuite>(testCaseName, testCaseMethod);
    }
 
    virtual int 
    listTestCases(
        std::ostream& out
    ) const
    {
        std::vector<std::string> names;
        for(const auto& testCase : cases)
        {
            names.push_back(testCase.first);
        }
        std::sort(names.begin(), names.end());
    
        for(const auto& name : names)
        {
            out << "\t" << suiteName << ":" << name << "\n";
        }
    
        return cases.size();
    }
 
    virtual Count 
    run(
        Logger& logger 
    )
    {
        logger.startSuite(suiteName);
 
        Count count;
        for(auto& nameCase : cases)
        {
            ++count.count;
            const bool passed = nameCase.second.run(static_cast<TestSuite&>(*this), logger);
            if(! passed)
            {
                ++count.fails;
            }
        }
    
        logger.endSuite(suiteName, count);
        return count;
    }
 
    virtual Count 
    run(
        Logger& logger, 
        const std::string& testCase 
    )
    {
        // Skip reporting the suite on individual tests
        Count count;
        ++count.count;
 
        const auto nameCase = cases.find(testCase);
        if(cases.end() == nameCase)
        {
            ++count.fails;
            return count;
        }
 
        const bool passed = nameCase->second.run(static_cast<TestSuite&>(*this), logger);
        if(! passed)
        {
            ++count.fails;
        }
 
        return count;
    }
 
};
 
}
 
#endif