TestFailure.h

Go to the documentation of this file.

#ifndef JON_TEST_TEST_FAILURE_H
#define JON_TEST_TEST_FAILURE_H
 
#include <exception>
#include <string>
#include <sstream>
 
namespace JonTest
{
 
class TestFailure
: public std::exception
{
public:
    std::string file;
 
    int line;
 
    std::string message;
 
    std::string firstExpression;
 
    std::string firstValue;
 
    std::string secondExpression;
 
    std::string secondValue;
 
    std::string operatorString;
 
    std::string whatString;
 
    inline TestFailure(
        const char* const file, 
        const int line, 
        const std::string& message 
    )
    :file(file),
    line(line),
    message(message),
    firstExpression(),
    secondExpression(),
    operatorString()
    {
        {
            std::ostringstream out;
            out << message << "\n\t\tAt " << file << ":" << line;
            whatString = out.str();
        }
    }
 
    template<typename Type1, typename Type2>
    inline TestFailure(
        const char* const file, 
        const int line, 
        const std::string& message, 
        const std::string& firstExpression, 
        const Type1& firstValue, 
        const std::string& secondExpression, 
        const Type2& secondValue, 
        const std::string& operatorString 
        )
    :file(file),
    line(line),
    message(message),
    firstExpression(firstExpression),
    secondExpression(firstExpression),
    operatorString(operatorString)
    {
        {
            std::ostringstream out;
            out << firstValue;
            this->firstValue = out.str();
        }
 
        {
            std::ostringstream out;
            out << secondValue;
            this->secondValue = out.str();
        }
 
        {
            std::ostringstream out;
            out << message << "\n\t\tAt " << file << ":" << line;
            if(!this->operatorString.empty()) {
                out << "\n\t\tExpression: " << firstExpression << " " << operatorString << " " << secondExpression << "\n";
                out << "\t\tValue: " << firstValue << " " << operatorString << " " << secondValue;
            }
            whatString = out.str();
        }
    }
 
    virtual ~TestFailure();
 
    virtual const char* what() const noexcept;
};
 
}
 
#endif