tb_unit_test.hpp

#ifndef TurtleBrains_UnitTest_hpp
#define TurtleBrains_UnitTest_hpp

#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_defines.hpp>
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_noncopyable.hpp>

#include <functional>
#include <string>
#include <cstdarg>

#define tbFailTestIf(test, failMessage, ...) { TurtleBrains::Core::UnitTest::FailTestIf((test) ? true : false, __FILE__, __LINE__, failMessage, ##__VA_ARGS__); }

#define tbFailTestIfNot(test, failMessage, ...) { TurtleBrains::Core::UnitTest::FailTestIf((test) ? false : true, __FILE__, __LINE__, failMessage, ##__VA_ARGS__); }

namespace TurtleBrains
{
    namespace Core
    {
        namespace UnitTest
        {

            void RunAllTests(const tbCore::tbString& testResultFile = "test_results.txt");

            void FailTestIf(bool testResult, const char* const fromFile, int onLineNumber, const char* const failMessage, ...);

            void Log(const char* const failMessage, ...);
            void Log(const char* const fromFile, int onLineNumber, const char* const failMessage, ...);
            void Log(const char* const fromFile, int onLineNumber, const char* const failMessage, va_list argumentList);

            class TestCaseInterface : public tbCore::Noncopyable
            {
            public:
                TestCaseInterface(const std::string& testName);
                virtual ~TestCaseInterface(void) = 0;

                const std::string& GetTestName(void) const { return mTestName; }
                const std::string& GetMessageBuffer(void) const { return mMessageBuffer; }

                bool RunTest(void);
                bool IsWeakTest(void) const { return mIsWeakTest; }

            protected:
                void SetWeakTest(void) { mIsWeakTest = true; }

                template <typename Type> bool ExpectedValue(const Type& value, const Type& expectedValue, const tbCore::tbString formattedMessage, ...)
                {
                    if (value == expectedValue)
                    {
                        return true;
                    }

                    va_list argumentsList;
                    va_start(argumentsList, formattedMessage);
                    FailedExpectation(formattedMessage, argumentsList);
                    va_end(argumentsList);
                    return false;
                }

                void FailTestIf(bool testResult, tbCore::tbString formattedMessage, ...);
                bool ExpectedValue(float value, float expectedValue, tbCore::tbString formattedMessage, ...);
                bool ExpectedValueWithin(float value, float expectedValue, float epsilon, tbCore::tbString formattedMessage, ...);
                bool ExpectedValue(double value, double expectedValue, tbCore::tbString formattedMessage, ...);
                bool ExpectedValueWithin(double value, double expectedValue, double epsilon, tbCore::tbString formattedMessage, ...);

                bool ExpectedValues(size_t numberOfValues, const float* values, const float* expectedValues, tbCore::tbString formattedMessage, ...);
                bool ExpectedValuesWithin(size_t numberOfValues, const float* values, const float* expectedValues, float epsilon, tbCore::tbString formattedMessage, ...);
                bool ExpectedValues(size_t numberOfValues, const double* values, const double* expectedValues, tbCore::tbString formattedMessage, ...);
                bool ExpectedValuesWithin(size_t numberOfValues, const double* values, const double* expectedValues, double epsilon, tbCore::tbString formattedMessage, ...);

                bool ExpectedException(std::function<void(void)> testCode, const tbCore::tbString formattedMessage, ...);

                virtual bool OnRunTest(void) = 0;

                void FailedExpectation(tbCore::tbString formattedMessage, va_list argumentList);

            private:
                const tbCore::tbString mTestName;
                tbCore::tbString mMessageBuffer;
                bool mAllExpectationPassed;
                bool mIsWeakTest;
            };

        }; /* namespace UnitTest */
    }; /* namespace Core */
}; /* namespace TurtleBrains */

namespace tbCore = TurtleBrains::Core;

#endif /* TurtleBrains_UnitTest_hpp */