/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "TestContext.h"

#include <util/AutoLock.h>

#include "Test.h"
#include "TestError.h"


static spinlock sLock = B_SPINLOCK_INITIALIZER;


// #pragma mark - TestOptions


TestOptions::TestOptions()
	:
	panicOnFailure(false),
	quitAfterFailure(false)
{
}


// #pragma mark - GlobalTestContext


struct GlobalTestContext::ThreadCookie {
	GlobalTestContext*	context;
	thread_func			function;
	void*				arg;

	ThreadCookie(GlobalTestContext* context, thread_func function, void* arg)
		:
		context(context),
		function(function),
		arg(arg)
	{
	}
};


/*static*/ GlobalTestContext::ThreadEntry* GlobalTestContext::sGlobalThreads
	= NULL;


GlobalTestContext::GlobalTestContext(TestOutput& output, TestOptions& options)
	:
	fThreads(NULL),
	fThreadEntry(this),
	fOutput(output),
	fOptions(options),
	fCurrentContext(NULL),
	fTotalTests(0),
	fFailedTests(0)
{
	_SetCurrent(&fThreadEntry);
}


GlobalTestContext::~GlobalTestContext()
{
	InterruptsSpinLocker locker(sLock);

	// remove all of our entries from the global list
	ThreadEntry** entry = &sGlobalThreads;
	while (*entry != NULL) {
		if ((*entry)->context == this)
			*entry = (*entry)->globalNext;
		else
			entry = &(*entry)->globalNext;
	}
}


/*static*/ GlobalTestContext*
GlobalTestContext::Current()
{
	thread_id thread = find_thread(NULL);

	InterruptsSpinLocker locker(sLock);

	ThreadEntry* entry = sGlobalThreads;
	while (entry != NULL) {
		if (entry->thread == thread)
			return entry->context;
		entry = entry->globalNext;
	}

	return NULL;
}


void
GlobalTestContext::SetCurrentContext(TestContext* context)
{
	fCurrentContext = context;
}


void
GlobalTestContext::TestDone(bool success)
{
	fTotalTests++;
	if (!success)
		fFailedTests++;
}


thread_id
GlobalTestContext::SpawnThread(thread_func function, const char* name,
	int32 priority, void* arg)
{
	ThreadCookie* cookie = new(std::nothrow) ThreadCookie(this, function, arg);
	if (cookie == NULL)
		return B_NO_MEMORY;

	thread_id thread = spawn_kernel_thread(_ThreadEntry, name, priority,
		cookie);
	if (thread < 0) {
		delete cookie;
		return thread;
	}

	return thread;
}


/*static*/ void
GlobalTestContext::_SetCurrent(ThreadEntry* entry)
{
	InterruptsSpinLocker locker(sLock);

	entry->contextNext = entry->context->fThreads;
	entry->context->fThreads = entry;

	entry->globalNext = sGlobalThreads;
	sGlobalThreads = entry;
}


/*static*/ void
GlobalTestContext::_UnsetCurrent(ThreadEntry* entryToRemove)
{
	InterruptsSpinLocker locker(sLock);

	// remove from the global list
	ThreadEntry** entry = &sGlobalThreads;
	while (*entry != NULL) {
		if (*entry == entryToRemove) {
			*entry = (*entry)->globalNext;
			break;
		}

		entry = &(*entry)->globalNext;
	}

	// remove from the context's list
	entry = &entryToRemove->context->fThreads;
	while (*entry != NULL) {
		if (*entry == entryToRemove) {
			*entry = (*entry)->contextNext;
			break;
		}

		entry = &(*entry)->contextNext;
	}
}


/*static*/ status_t
GlobalTestContext::_ThreadEntry(void* data)
{
	ThreadCookie* cookie = (ThreadCookie*)data;

	ThreadEntry entry(cookie->context);
	_SetCurrent(&entry);

	thread_func function = cookie->function;
	void* arg = cookie->arg;
	delete cookie;

	status_t result = function(arg);

	_UnsetCurrent(&entry);

	return result;
}


// #pragma mark - TestContext


TestContext::TestContext(GlobalTestContext* globalContext)
	:
	fGlobalContext(globalContext),
	fParent(NULL),
	fTest(NULL),
	fErrors(NULL),
	fLevel(0)
{
	fGlobalContext->SetCurrentContext(this);
}


TestContext::TestContext(TestContext& parent, Test* test)
	:
	fGlobalContext(parent.GlobalContext()),
	fParent(&parent),
	fTest(test),
	fErrors(NULL),
	fLevel(parent.Level() + 1)
{
	fGlobalContext->SetCurrentContext(this);

	if (fTest != NULL) {
		if (fTest->IsLeafTest())
			Print("%*s%s...", fLevel * 2, "", test->Name());
		else
			Print("%*s%s:\n", fLevel * 2, "", test->Name());
	}
}


TestContext::~TestContext()
{
	fGlobalContext->SetCurrentContext(fParent);

	while (fErrors != NULL) {
		TestError* error = fErrors;
		fErrors = error->ListLink();
		delete error;
	}
}


void
TestContext::TestDone(bool success)
{
	if (fTest != NULL && fTest->IsLeafTest()) {
		if (success) {
			Print(" ok\n");
		} else {
			Print(" FAILED\n");
			TestError* error = fErrors;
			while (error != NULL) {
				Print("%s", error->Message());
				error = error->ListLink();
			}
		}

		fGlobalContext->TestDone(success);
	}
}


void
TestContext::ErrorArgs(const char* format, va_list args)
{
	int size = vsnprintf(NULL, 0, format, args) + 1;
	char* buffer = (char*)malloc(size);
	if (buffer == NULL)
		return;

	vsnprintf(buffer, size, format, args);

	TestError* error = new(std::nothrow) TestError(fTest, buffer);
	if (error == NULL) {
		free(buffer);
		return;
	}

	InterruptsSpinLocker locker(sLock);
	error->ListLink() = fErrors;
	fErrors = error;

	if (Options().panicOnFailure)
		panic("Test check failed: %s", error->Message());
}