UnitTestFrameWork.cpp #1

#include "StdAfx.h"
#include "UnitTestFrameWork.h"
#include <excpt.h>
#include <Shellapi.h>

void UnitTestSuite::RegisterTest(UnitTest * test, char * testName)
{
	TestList * newTest = new TestList();
	newTest->TestName = testName;
	newTest->Test = test;
	newTest->pNext = 0;

	if (pLastTest)
	{
		pLastTest->pNext = newTest;
		pLastTest = newTest;
	}
	else
	{
		pFirstTest = newTest;
		pLastTest = newTest;
	}
}

UnitTestSuite::UnitTestSuite()
{
	pFirstTest = 0;
	pLastTest = 0;

	pNextTestSuite = 0;
}

UnitTestSuite::~UnitTestSuite()
{
	TestList * pCurTest = pFirstTest;
	while(pCurTest)
	{
		pFirstTest = pFirstTest->pNext;
		delete pCurTest;
		pCurTest = pFirstTest;
	}

	pFirstTest = 0;
	pLastTest = 0;

	pNextTestSuite = 0;
}

int UnitTestSuite::HandleException(unsigned int c, struct _EXCEPTION_POINTERS *e)
{
	unsigned int code = 0;
	struct _EXCEPTION_POINTERS *ep = NULL;
	
	code = c;
	ep = e;

	printf("\tException Detected: ");

	switch (code)
	{
	case EXCEPTION_ACCESS_VIOLATION:
		printf("EXCEPTION_ACCESS_VIOLATION\r\n");
		break;
	case EXCEPTION_DATATYPE_MISALIGNMENT:
		printf("EXCEPTION_DATATYPE_MISALIGNMENT\r\n");
		break;
	case EXCEPTION_BREAKPOINT:
		printf("EXCEPTION_BREAKPOINT\r\n");
		break;
	case EXCEPTION_SINGLE_STEP:
		printf("EXCEPTION_SINGLE_STEP\r\n");
		break;
	case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
		printf("EXCEPTION_ARRAY_BOUNDS_EXCEEDED\r\n");
		break;
	case EXCEPTION_FLT_DENORMAL_OPERAND:
		printf("EXCEPTION_FLT_DENORMAL_OPERAND\r\n");
		break;
	case EXCEPTION_FLT_DIVIDE_BY_ZERO:
		printf("EXCEPTION_FLT_DIVIDE_BY_ZERO\r\n");
		break;
	case EXCEPTION_FLT_INEXACT_RESULT:
		printf("EXCEPTION_FLT_INEXACT_RESULT\r\n");
		break;
	case EXCEPTION_FLT_INVALID_OPERATION:
		printf("EXCEPTION_FLT_INVALID_OPERATION\r\n");
		break;
	case EXCEPTION_FLT_OVERFLOW:
		printf("EXCEPTION_FLT_OVERFLOW\r\n");
		break;
	case EXCEPTION_FLT_STACK_CHECK:
		printf("EXCEPTION_FLT_STACK_CHECK\r\n");
		break;
	case EXCEPTION_FLT_UNDERFLOW:
		printf("EXCEPTION_FLT_UNDERFLOW\r\n");
		break;
	case EXCEPTION_INT_DIVIDE_BY_ZERO:
		printf("EXCEPTION_INT_DIVIDE_BY_ZERO\r\n");
		break;
	case EXCEPTION_INT_OVERFLOW:
		printf("EXCEPTION_INT_OVERFLOW\r\n");
		break;
	case EXCEPTION_PRIV_INSTRUCTION:
		printf("EXCEPTION_PRIV_INSTRUCTION\r\n");
		break;
	case EXCEPTION_IN_PAGE_ERROR:
		printf("EXCEPTION_IN_PAGE_ERROR\r\n");
		break;
	case EXCEPTION_ILLEGAL_INSTRUCTION:
		printf("EXCEPTION_ILLEGAL_INSTRUCTION\r\n");
		break;
	case EXCEPTION_NONCONTINUABLE_EXCEPTION:
		printf("EXCEPTION_NONCONTINUABLE_EXCEPTION\r\n");
		break;
	case EXCEPTION_STACK_OVERFLOW:
		printf("EXCEPTION_STACK_OVERFLOW\r\n");
		break;
	case EXCEPTION_INVALID_DISPOSITION:
		printf("EXCEPTION_INVALID_DISPOSITION\r\n");
		break;
	case EXCEPTION_GUARD_PAGE:
		printf("EXCEPTION_GUARD_PAGE\r\n");
		break;
	case EXCEPTION_INVALID_HANDLE:
		printf("EXCEPTION_INVALID_HANDLE\r\n");
		break;
	//case EXCEPTION_POSSIBLE_DEADLOCK:
	//    printf("EXCEPTION_POSSIBLE_DEADLOCK\r\n");
	//    break;
	default:
		printf("UNKOWN EXCEPTION\r\n");
		break;
	}
	return EXCEPTION_EXECUTE_HANDLER;
}

LPPROCESS_INFORMATION UnitTestSuite::RunProgram(char * cmdLine, char * cwd, bool newConsole, bool waitForExit)
{
	LPSTARTUPINFOA si = new STARTUPINFOA;
	LPPROCESS_INFORMATION pi = new PROCESS_INFORMATION;

	ZeroMemory( si, sizeof(STARTUPINFOA) );
	si->cb = sizeof(si);
	ZeroMemory( pi, sizeof(PROCESS_INFORMATION) );

	// Start the child process. 
	if( !CreateProcessA( 
		NULL,           // No module name (use command line)
		cmdLine,        // Command line
		NULL,           // Process handle not inheritable
		NULL,           // Thread handle not inheritable
		FALSE,          // Set handle inheritance to FALSE
		newConsole?CREATE_NEW_CONSOLE:0,              // No creation flags
		NULL,           // Use parent's environment block
		cwd,            // Starting directory 
		si,             // Pointer to STARTUPINFO structure
		pi )            // Pointer to PROCESS_INFORMATION structure
	) 
	{
		printf( "CreateProcess failed (%d).\n", GetLastError() );
		return NULL;
	}
	if (waitForExit)
	{
		// Wait until child process exits.
		WaitForSingleObject( pi->hProcess, INFINITE );

		// Close process and thread handles. 
		CloseHandle( pi->hProcess );
		CloseHandle( pi->hThread );
	}
	delete si;

	return pi;
}

bool UnitTestSuite::EndProcess(LPPROCESS_INFORMATION pi)
{
	TerminateProcess( pi->hProcess, 0);
	
	// Wait until child process exits.
	WaitForSingleObject( pi->hProcess, INFINITE );

	// Close process and thread handles. 
	CloseHandle( pi->hProcess );
	CloseHandle( pi->hThread );

	delete pi;

	return true;
}

bool UnitTestSuite::rmDir(char * path)
{
	char szDir[MAX_PATH+1];  // +1 for the double null terminate

	SHFILEOPSTRUCTA fos = {0};

	strcpy(szDir, path);
	int len = strlen(szDir);
	szDir[len+1] = 0; // double null terminate for SHFileOperation

	// delete the folder and everything inside
	fos.wFunc = FO_DELETE;
	fos.pFrom = szDir;
	fos.fFlags = FOF_NO_UI;
	return SHFileOperation( &fos );
}

void UnitTestSuite::RunTests()
{
	TestList * pCurrentTest = pFirstTest;

	while (pCurrentTest)
	{
		unsigned int code = 0;
		struct _EXCEPTION_POINTERS *ep = NULL;

		__try 
		{
			printf("Test %s:\r\n", pCurrentTest->TestName);

			if (!Setup())
			{
				printf("\tSetup  Failed!!\r\n");
				UnitTestFrameWork::IncrementTestsFailed();

				if (endOnFailure)
					return;
			}
			else
			{
				bool passed = (*pCurrentTest->Test)();
				bool tearDownPassed = TearDown(pCurrentTest->TestName);
				if (passed)
					printf("\tPassed\r\n");
				else 
					printf("\t<<<<***Failed!!***>>>>\r\n");

				if (!tearDownPassed)
					printf("\tTearDown Failed!!\r\n");

				if (!passed || !tearDownPassed)
				{
					UnitTestFrameWork::IncrementTestsFailed();
					if (endOnFailure)
						return;
				}
				UnitTestFrameWork::IncrementTestsPassed();
			}
		} 
		__except (HandleException(GetExceptionCode(), GetExceptionInformation()))
		{
			UnitTestFrameWork::IncrementTestsFailed();
			if (endOnFailure)
				return;
		}
		pCurrentTest = pCurrentTest->pNext;
	}

	if (pNextTestSuite)
		pNextTestSuite->RunTests();
}

bool UnitTestSuite::Assert(bool condition, char* FailStr, int Line, char * FileName)
{
	if (condition) // It's as expected
		return true;

	if (breakOnFailure)
		__debugbreak();

	printf("\t%s: Line: %d, %s:\r\n", FailStr, Line, FileName);
	return false;
}

bool UnitTestSuite::breakOnFailure = false;

bool UnitTestSuite::endOnFailure = false;

UnitTestFrameWork::UnitTestFrameWork(void)
{
}

UnitTestSuite * UnitTestFrameWork::pFirstTestSuite = 0;
UnitTestSuite * UnitTestFrameWork::pLastTestSuite = 0;

void UnitTestFrameWork::RegisterTestSuite(UnitTestSuite * pSuite)
{
	if (pLastTestSuite)
	{
		pLastTestSuite->NextTestSuite(pSuite);
		pLastTestSuite = pSuite;
	}
	else
	{
		pFirstTestSuite = pSuite;
		pLastTestSuite = pSuite;
	}
}

int UnitTestFrameWork::testsPassed = 0;
int UnitTestFrameWork::testsFailed = 0;

void UnitTestFrameWork::RunTests()
{
	testsPassed = 0;
	testsFailed = 0;

	if (pFirstTestSuite)
		pFirstTestSuite->RunTests();

	printf("Tests Passed %d, TestFailed: %d\r\n", testsPassed, testsFailed);

	// delete all the test suites
	while (pFirstTestSuite)
	{
		UnitTestSuite * pCurrentTestSuite = pFirstTestSuite;
		pFirstTestSuite = pCurrentTestSuite->NextTestSuite();
		delete pCurrentTestSuite;
	}
	p4base::Cleanup();
}