simpletest.h

#pragma once

//---------------------------------------------------------------------------------
// Config
//---------------------------------------------------------------------------------
#if !defined(MESSAGE_SPACE)
#define MESSAGE_SPACE 10 * 1024 // default 10k of message space is reserved per test
#endif
#if !defined(STRING_LENGTH)
#define STRING_LENGTH 64 // size of temp strings for converting types
#endif
#if !defined(STRING_EQ_PRINT_LENGTH)
#define STRING_EQ_PRINT_LENGTH 80 // max line length to show when comparing two strings
#endif
#if !defined(BASE_FIXTURE)
#define BASE_FIXTURE TestFixture // use TestFixture as the test base class by default
#endif
#if !defined(ERROR_ACTION)
#define ERROR_ACTION // Defined any code to run on error. You can use this to debug break or do anything really
#endif

//---------------------------------------------------------------------------------
// Link list of errors build into MESSAGE_SPACE
//---------------------------------------------------------------------------------
struct TestError
{
	TestError* next;
	char message[1];
};

//---------------------------------------------------------------------------------
// simple converter of basic types to text
// TODO: Use a global template function for conversion so users can override this
//---------------------------------------------------------------------------------
struct TempString
{
	TempString() : myTextPointer(myTextBuffer) { myTextBuffer[0] = 0; }
	TempString(const TempString& other);
	TempString(char const* string) : myTextPointer(string) {}

	char const* operator*() const { return myTextPointer; }

	char const* myTextPointer;
	char myTextBuffer[STRING_LENGTH];
};

TempString TypeToString(int value);
TempString TypeToString(unsigned int value);
TempString TypeToString(long value);
TempString TypeToString(unsigned long value);
TempString TypeToString(long long value);
TempString TypeToString(unsigned long long value);
TempString TypeToString(float value);
TempString TypeToString(double value);
TempString TypeToString(bool value);
TempString TypeToString(char const* value);
TempString TypeToString(void const* value);
TempString TypeToString(void const* value, char const* extra);

inline TempString TypeToString(char value) { return TypeToString((int)value); }
inline TempString TypeToString(unsigned char value) { return TypeToString((unsigned int)value); }
inline TempString TypeToString(short value) { return TypeToString((int)value); }
inline TempString TypeToString(unsigned short value) { return TypeToString((unsigned int)value); }
inline TempString TypeToString(char* value) { return TypeToString((char const*)value); }
inline TempString TypeToString(void* value) { return TypeToString((void const*)value); }

// if nothing specified then print some memory
template<typename T>
TempString TypeToString(T const&) { return TempString(); }

template<typename T>
TempString TypeToString(T const* pointer)
{
	return pointer == nullptr ?
		TypeToString((void const*)pointer) :
		TypeToString((void const*)pointer, *TypeToString(*pointer));
}

template<typename T>
TempString TypeToString(T* pointer) { return TypeToString((T const*)pointer); }

inline TempString TypeToStringFallback(TempString string, char const* fallback) { return (*string)[0] ?  string : TempString(fallback); }

//---------------------------------------------------------------------------------
// Test fixture is the core of SimpleTest. It provides fixture behavior, access
// to registered tests and stores the results of a test run
// Everything is local here so tests can be multithreaded without any extra work
//---------------------------------------------------------------------------------
class TestFixture
{
public:
	TestFixture();
	virtual ~TestFixture() {};

	virtual bool ExecuteTest();

	virtual char const* TestName() const = 0;
	virtual char const* TestGroup() const = 0;

	// Reporting used during testing process
	void AddTest() { ++myNumTestsChecked; }
	void AddError() { ++myNumErrors; }
	void LogMessage(char const* string, ...);

	// Custom test for strings to print out where the comparison failed
	bool TestStrings(char const* left, char const* right, char const* prefix, char const* condition);

	// Stats from execution
	int NumTests() const { return myNumTestsChecked; }
	int NumErrors() const { return myNumErrors; }

	// Access to any errrors generated
	TestError const* GetFirstError() const { return (TestError*)myMessageSpace; }
	TestError const* GetLastError() const { return myNextError; }

	// Access to registered tests
	static TestFixture* GetFirstTest() { return ourFirstTest; }
	static TestFixture* GetCurrentTest() { return ourCurrentTest; }
	TestFixture* GetNextTest() const { return myNextTest; }

	enum OutputMode
	{
		Silent,
		Normal,
		Verbose
	};

	enum PrintMethod
	{
		PrintDefault,
		PrintHexadecimal,
	};

	PrintMethod GetPrintMethod() const { return myPrintMethod; }
	void SetPrintMethod(PrintMethod aPrintMethod) { myPrintMethod = aPrintMethod; }

	// Default execution implementation
	static void (*Print)(char const* string);
	static void Printf(char const* string, ...);

	static bool ExecuteAllTests(char const* groupFilter = nullptr, char const* nameFilter = nullptr, OutputMode output = Normal);
	static bool ExecuteAllTests(OutputMode output) { return ExecuteAllTests(nullptr, nullptr, output); }

	static bool ExecuteTestGroup(char const* groupFilter, OutputMode output = Normal) { return ExecuteAllTests(groupFilter, nullptr, output); }

protected:
	virtual void RunTest() = 0;
	virtual void Setup() {}
	virtual void TearDown() {}
	
	// Test registration
	static TestFixture const* LinkTest(TestFixture* test);
	static TestFixture* ourFirstTest;
	static TestFixture* ourLastTest;

	TestFixture* myNextTest;
	TestError* myNextError;

	int myNumTestsChecked;
	int myNumErrors;

	PrintMethod myPrintMethod;

	char myMessageSpace[MESSAGE_SPACE];

	// allow access to current test outside of main code block
	static thread_local TestFixture* ourCurrentTest;
};

//---------------------------------------------------------------------------------
// Test definition macros
//---------------------------------------------------------------------------------
#define DEFINE_TEST_FULL(name, group, fixture) \
struct TOK(group, name) final : public fixture { \
	char const* TestName() const override { return #name; } \
	char const* TestGroup() const override { return #group; } \
	void RunTest() override; \
} TOK(TOK(group, name), Instance); \
void TOK(group, name)::RunTest()

#define DEFINE_TEST(name) DEFINE_TEST_FULL(name, Global, BASE_FIXTURE)
#define DEFINE_TEST_G(name, group) DEFINE_TEST_FULL(name, group, BASE_FIXTURE)
#define DEFINE_TEST_F(name, fixture) DEFINE_TEST_FULL(name, Global, fixture)
#define DEFINE_TEST_GF(name, group, fixture) DEFINE_TEST_FULL(name, group, fixture)

//---------------------------------------------------------------------------------
// Utils
//---------------------------------------------------------------------------------
template <typename T>
T TestDifference(T const& a, T const& b) { return a > b ? a - b : b - a; }

// why are these still needed?
#define STR2(x) #x
#define STR(x) STR2(x)

#define TOK2(a, b) a ## b
#define TOK(a, b) TOK2(a, b)

//---------------------------------------------------------------------------------
// Error reporting and setup, don't call directly
//---------------------------------------------------------------------------------
#define TEST_TYPE_TO_STRING(var, arg) *TypeToStringFallback(TypeToString(var), STR(arg))
#define TEST_ERROR_PREFIX_ __FILE__ "(" STR(__LINE__) "): Condition [%s] Failed. "
#define TEST_ERROR_(message, ...) do { TestFixture* __fx = TestFixture::GetCurrentTest(); __fx->AddError(); __fx->LogMessage(TEST_ERROR_PREFIX_ message, ##__VA_ARGS__); ERROR_ACTION; } while(0)
#define TEST_BEGIN_(a) do { auto const& test_value_ = a
#define TEST_CHECK_(cond, condtext, message, ...) do { TestFixture::GetCurrentTest()->AddTest(); if (!(cond)) TEST_ERROR_(message, condtext, ##__VA_ARGS__); } while(0)
#define TEST_END_ } while(0)

//---------------------------------------------------------------------------------
// Tests
//
// Note: Value caching is only enabled on left hand side. This splits the difference
// between preventing side effects (i.e. x++ double incrementing) and allowing the
// compiler to infer values (i.e. TEST_EQ(unsigned(1), 1) will try to cache 1 as an int then omit a compile warning).
// This means that the right hand side will get evaluated multiple times, so please avoid
// expressions like: TEST_EQ(a++, b++) as they won't work. Tests should always be written
// as following:
// TEST_EQ(expression, constant)
//---------------------------------------------------------------------------------
#define TEST_OPERATOR(a, b, op1, op2) TEST_BEGIN_(a); TEST_CHECK_((test_value_) op1 (b), STR(a) " " STR(op1) " " STR(b), "'%s' " STR(op2) " '%s'", TEST_TYPE_TO_STRING(test_value_, a), TEST_TYPE_TO_STRING(b, b)); TEST_END_

#define TEST(cond) TEST_EQ(cond, true)
#define TEST_FAIL(cond) TEST_EQ(cond, false)

#define TEST_EQ(a, b) TEST_OPERATOR(a, b, ==, !=)
#define TEST_NEQ(a, b) TEST_OPERATOR(a, b, !=, ==)
#define TEST_GREATER(a, b) TEST_OPERATOR(a, b, >, <=)
#define TEST_GREATER_EQUAL(a, b) TEST_OPERATOR(a, b, >=, <)
#define TEST_LESS(a, b) TEST_OPERATOR(a, b, <, >=)
#define TEST_LESS_EQUAL(a, b) TEST_OPERATOR(a, b, <=, >)

#define TEST_STR_EQ(a, b) do { if(!TestFixture::GetCurrentTest()->TestStrings(a, b, TEST_ERROR_PREFIX_ "\n%s\n%s\n%s", STR(a) " == " STR(b))) { ERROR_ACTION; } } while(0)
#define TEST_CLOSE(a, b, eps) TEST_BEGIN_(TestDifference(a, b)); TEST_CHECK_(test_value_ <= eps, STR(a) " Close to " STR(b), "Difference of %s is greater than expected amount of " STR(eps) " when comparing %s and %s", TEST_TYPE_TO_STRING(test_value_, TestDifference(a, b)), TEST_TYPE_TO_STRING(a, a), TEST_TYPE_TO_STRING(b, b)); TEST_END_
#define TEST_DIFFERS(a, b, eps) TEST_BEGIN_(TestDifference(a, b)); TEST_CHECK_(test_value_ >= eps, STR(a) " Differs from " STR(b), "Difference of %s is less than expected amount of " STR(eps) " when comparing %s and %s", TEST_TYPE_TO_STRING(test_value_, TestDifference(a, b)), TEST_TYPE_TO_STRING(a, a), TEST_TYPE_TO_STRING(b, b)); TEST_END_
#define TEST_MESSAGE(cond, message, ...) TEST_BEGIN_(cond); TEST_CHECK_(test_value_, STR(cond), message, ##__VA_ARGS__); TEST_END_