tb_unit_test.h

#ifndef _TurtleBrains_UnitTest_h_
#define _TurtleBrains_UnitTest_h_

#include "../tb_configuration.h"
#include "../tb_defines.h"
#include "../tb_string.h"
#include "../tb_noncopyable.h"

#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
        {

            extern const float kEpsilon;

            void RunAllTests(void);

            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);

            protected:
                template <typename Type> bool ExpectedValue(const Type& value, const Type& expectedValue, const tbCore::tbString formattedMessage, ...)
                {
                    if (value != expectedValue)
                    {
                        va_list argumentsList;
                        va_start(argumentsList, formattedMessage);
                        FailedExpectation(formattedMessage, argumentsList);
                        va_end(argumentsList);
                        return false;
                    }
                    return true;
                }

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

                virtual bool OnRunTest(void) = 0;

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

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

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

namespace tbCore = TurtleBrains::Core;

#endif /* _TurtleBrains_UnitTest_h_ */