/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef _UNIT_TEST_UTILS_H
#define _UNIT_TEST_UTILS_H

static timespec*
absolute_timeout(timespec& timeout, bigtime_t relativeTimeout)
{
	timeval tv;
	gettimeofday(&tv, NULL);
	timeout.tv_sec = tv.tv_sec + relativeTimeout / 1000000;
	timeout.tv_nsec = (tv.tv_usec + relativeTimeout % 1000000) * 1000;
	if (timeout.tv_nsec > 1000000000) {
		timeout.tv_sec++;
		timeout.tv_nsec -= 1000000000;
	}

	return &timeout;
}


template<typename Type>
static void
_assert_equals(const char* test, const Type& expected, const Type& actual,
	int lineNumber)
{
	if (actual == expected)
		return;

	fprintf(stderr, "%s FAILED in line %d\n", test, lineNumber);
	exit(1);
}


template<typename Type>
static void
_assert_equals_not(const char* test, const Type& unexpected, const Type& actual,
	int lineNumber)
{
	if (actual != unexpected)
		return;

	fprintf(stderr, "%s FAILED in line %d\n", test, lineNumber);
	exit(1);
}


static void
_assert_time_equals(const char* test, bigtime_t expected,
	bigtime_t actual, int lineNumber)
{
	// allow 5% deviation
	bigtime_t diff = actual > expected ? actual - expected : expected - actual;
	if (diff <= expected / 20)
		return;

	fprintf(stderr, "%s FAILED in line %d: expected time: %lld, actual: %lld\n",
		test, lineNumber, (long long)expected, (long long)actual);
	exit(1);
}


static void
_assert_posix_bool_success(const char* test, bool success, int lineNumber)
{
	if (success)
		return;

	fprintf(stderr, "%s FAILED in line %d: %s\n", test, lineNumber,
		strerror(errno));
	exit(1);
}


static void
_assert_posix_bool_error(const char* test, int expectedError, bool success,
	int lineNumber)
{
	if (success) {
		fprintf(stderr, "%s FAILED in line %d: call succeeded unexpectedly\n",
			test, lineNumber);
		exit(1);
	}

	if (errno != expectedError) {
		fprintf(stderr, "%s FAILED in line %d: call set unexpected error "
			"code \"%s\" (0x%x), expected: \"%s\" (0x%x)\n", test, lineNumber,
			strerror(errno), errno, strerror(expectedError), expectedError);
		exit(1);
	}
}


static void
test_set(const char* testSet)
{
	printf("\nTEST SET: %s\n", testSet);
}


static void
test_ok(const char* test)
{
	if (test != NULL)
		printf("%s OK\n", test);
}


static void
_wait_for_child(const char* test, pid_t child, int lineNumber)
{
	int status;
	pid_t result = wait(&status);
	_assert_posix_bool_success(test, result >= 0, lineNumber);
	_assert_equals(test, child, result, lineNumber);
	_assert_equals(test, 0, status, lineNumber);
}


#define TEST_SET(testSet)	test_set(testSet)
#define TEST(test)	test_ok(currentTest); currentTest = (test)

#define assert_equals(expected, actual) \
	_assert_equals(currentTest, (expected), (actual), __LINE__)

#define assert_equals_not(expected, actual) \
	_assert_equals_not(currentTest, (expected), (actual), __LINE__)

#define assert_time_equals(expected, actual) \
	_assert_time_equals(currentTest, (expected), (actual), __LINE__)

#define assert_posix_bool_success(success) \
	_assert_posix_bool_success(currentTest, (success), __LINE__)

#define assert_posix_success(result) \
	_assert_posix_bool_success(currentTest, (result) == 0, __LINE__)

#define assert_posix_bool_error(expectedError, success) \
	_assert_posix_bool_error(currentTest, (expectedError), (success), __LINE__)

#define assert_posix_error(expectedError, result) \
	_assert_posix_bool_error(currentTest, (expectedError), (result) == 0, \
		__LINE__)

#define wait_for_child(child) \
	_wait_for_child(currentTest, (child), __LINE__)

#endif // _UNIT_TEST_UTILS_H