TestCase.h

Go to the documentation of this file.

#ifndef JON_TEST_TEST_CASE_H
#define JON_TEST_TEST_CASE_H
 
#include "JonTest/Logger.h"
#include "JonTest/TestFailure.h"
 
#include <string>
 
namespace JonTest
{
 
template <typename TestSuiteDerived>
class TestCase
{
public:
    typedef TestSuiteDerived TestSuite;
 
    typedef void (TestSuite::*TestCaseMethod)();
 
    std::string name;
 
    TestCaseMethod testCaseMethod;
 
    static TestCase createAndAdd(
        TestSuite& suite, 
        const char* const testCaseName, 
        TestCaseMethod const testCaseMethod 
    )
    {
        suite.add(testCaseName, testCaseMethod);
        return TestCase(testCaseName, testCaseMethod);
    }
 
    TestCase() = default;
 
   TestCase(const TestCase& right) = default;
 
    TestCase(
        const char* const testCaseName, 
        TestCaseMethod const testCaseMethod 
    )
    : name(testCaseName),
    testCaseMethod(testCaseMethod)
    {
        // Nothing to do
    }
 
    ~TestCase()
    {
        // Nothing to do. DO NOT DELETE pointer-to-member testCaseMethod.
    }
 
    bool 
    run(
        TestSuite& suite, 
        Logger& logger 
    ) const
    {
        logger.startCase(suite.getName(), name);
 
        if(nullptr == testCaseMethod)
        {
            logger.errorCase(suite.getName(), name, "(internal)", "Internal Error: MISSING test case method");
            return false;
        }
    
        // Note: We use compressed/multiple-statements-per-line for clarity here
        bool setupPassed = false;
        try { suite.setup(); setupPassed = true; }
        catch(TestFailure& failure)       { logger.failCase(suite.getName(), name, "setup", failure); }
        catch(std::exception& unexpected) { logger.exceptionCase(suite.getName(), name, "setup", unexpected); }
        catch(...)                        { logger.errorCase(suite.getName(), name, "setup", "UNKNOWN EXCEPTION"); }
 
        bool casePassed = false;
        if(setupPassed) {
            try { (suite.* testCaseMethod)(); casePassed = true; }
            catch(TestFailure& failure)       { logger.failCase(suite.getName(), name, "case", failure); }
            catch(std::exception& unexpected) { logger.exceptionCase(suite.getName(), name, "case", unexpected); }
            catch(...)                        { logger.errorCase(suite.getName(), name, "case", "UNKNOWN EXCEPTION"); }
        }
        
        bool teardownPassed = false;
        try { suite.teardown(); teardownPassed = true; }
        catch(TestFailure& failure)       { logger.failCase(suite.getName(), name, "teardown", failure); }
        catch(std::exception& unexpected) { logger.exceptionCase(suite.getName(), name, "teardown", unexpected); }
        catch(...)                        { logger.errorCase(suite.getName(), name, "teardown", "UNKNOWN EXCEPTION"); }
 
        const bool passed = setupPassed && casePassed && teardownPassed;            
        logger.endCase(suite.getName(), name, passed);
        return passed;
    }
};
 
}
 
#endif