// TestFW.cpp: implementation of the CTestFW class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "TestFW.h"

/*
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
*/

template <class T>
CTestFW<T>::CTestFW()
{
}

template <class T>
CTestFW<T>::~CTestFW()
{
}

template <class T>
void CTestFW<T>::InitTestItems()
{
	m_cTestItems = 0;
	ZeroMemory(m_TestItems, sizeof(m_TestItems));
	m_cFuncName = 0;
	ZeroMemory(m_FuncName, sizeof(m_FuncName));

	m_nCurrentItemNumber = 0;
}

template <class T>
void CTestFW<T>::AddFuncName(TCHAR* pName, TEST_FUNC func)
{
	ASSERT(m_cFuncName<MAX_TEST_ITEMS);
	ASSERT(_tcslen(pName)<MAX_PATH);

	_tcsncpy(m_FuncName[m_cFuncName].sName, pName, MAX_PATH);
	m_FuncName[m_cFuncName].sName[MAX_PATH] = NULL;
	m_FuncName[m_cFuncName].fnFunc = func;

	m_cFuncName++;
}

template <class T>
BOOL CTestFW<T>::RunTest()
{
	BOOL bAllTested = FALSE;
	int i;

	MSG_TEST_NOTE((_T("\r\nThere are %d tests.\r\n"),m_cTestItems));

	ShowDuplicatedTest();

	if (!CheckWhetherAllTestFunctionNameAreRegistered()) {
		MSG_TEST_NOTE((_T("\r\nTesting is aborted.\r\n")));
		return FALSE;
	}

	while (!bAllTested) {
		bAllTested = TRUE;
		for (i=0; i<m_cTestItems; i++) {
			if (TS_NOT_TESTED==m_TestItems[i].fTestStatus) {
				if (IsRequiredTestTested(i)) {
					DoMainTest(i);
				}
			}
		}
		for (i=0; i<m_cTestItems; i++) {
			if (TS_NOT_TESTED==m_TestItems[i].fTestStatus) {
				bAllTested = FALSE;
				break;
			}
		}
	}

	//MSG_TEST_OK((_T("(End of Test)\r\n")));
	//MSG_TEST_LOG((_T("(End of Test)\r\n")));
	//MSG_TEST_FAILED((_T("(End of Test)\r\n")));
	MSG_TEST_NOTE((_T("\r\n[%d] HW Test Complete.\r\n"),m_cTestItems));

	return TRUE;
}

template <class T>
BOOL CTestFW<T>::IsRequiredTestTested(int testIdx)
{
	// TRUE·Î ÇØ ³õ°í, Å×½ºÆ® OK µÇÁö ¾ÊÀº ÇÔ¼ö°¡ ÀÖÀ¸¸é FALSE ·Î ÇÑ´Ù.
	BOOL bIsAllRequiredTestsTestedOk = TRUE;

	// ¸ÕÀú ¼öÇàµÇ¾î¾ß ÇÒ ÇÔ¼öµéÀ» ã´Â´Ù.
	for (int j=0; j<MAX_TEST_FUNC; j++) {
		if (m_TestItems[testIdx].fnRequired[j]) {
			
			BOOL bMainFuncFound = FALSE;

			// ¼±ÇàÇÏ¿© ¼öÇàµÇ¾î¾ß ÇÒ ÇÔ¼ö°¡ main ÇÔ¼öÀÎ °ÍÀ» ã´Â´Ù.
			for (int k=0; k<m_cTestItems; k++) {

				if (m_TestItems[k].fnMain[0] == m_TestItems[testIdx].fnRequired[j]) {
					bMainFuncFound = TRUE;

					if (TS_NOT_TESTED==m_TestItems[k].fTestStatus) {
						return FALSE;
					}

					if (TS_TEST_OK!=m_TestItems[k].fTestStatus) {
						bIsAllRequiredTestsTestedOk = FALSE;

						// Required ÇÔ¼öÀÇ Å×½ºÆ® °á°ú°¡ FAILED, CANCELED¸é mainÇÔ¼ö ¿ª½Ã Å×½ºÆ®¸¦ Ãë¼Ò½ÃŲ´Ù.
						m_TestItems[testIdx].fTestStatus = TS_TEST_CANCELED;
						TCHAR* pFuncName = NULL;
						TCHAR* pFuncName1 = NULL;
						GetFunctionName(m_TestItems[testIdx].fnMain[0], &pFuncName);
						GetFunctionName(m_TestItems[testIdx].fnRequired[j], &pFuncName1);
						char strTestResult[50];
						switch(m_TestItems[k].fTestStatus) {
						case TS_TEST_FAILED:
							strcpy(strTestResult, "failed");
							break;
						case TS_TEST_CANCELED:
							strcpy(strTestResult, "canceled");
							break;
						default:
							strcpy(strTestResult, "?");
							ASSERT(!"¿Í¼­´Â ¾ÈµÉ »óÅÂÀÌ´Ù.");
							break;
						}
						MSG_TEST_FAILED((_T("T[%03d] %s is canceled, because required test %s has been %s\r\n"),testIdx,pFuncName,pFuncName1,strTestResult));

						return FALSE;
					}
					break;
				}
			}
			if (!bMainFuncFound) {
				// Required ÇÔ¼öÁß¿¡ Main ÇÔ¼ö·Î µî·ÏµÇ¾î ÀÖÁö ¾ÊÀº ÇÔ¼ö´Â Å×½ºÆ®¸¦ Ãë¼Ò½ÃŲ´Ù.
				m_TestItems[testIdx].fTestStatus = TS_TEST_CANCELED;
				TCHAR* pFuncName = NULL;
				TCHAR* pFuncName1 = NULL;
				GetFunctionName(m_TestItems[testIdx].fnMain[0], &pFuncName);
				GetFunctionName(m_TestItems[testIdx].fnRequired[j], &pFuncName1);
				MSG_TEST_FAILED((_T("T[%03d] %s is canceled, because required test %s has not been registered.\r\n"),testIdx,pFuncName,pFuncName1));
				return FALSE;
			}
		}
	}

	return bIsAllRequiredTestsTestedOk;
}

template <class T>
void CTestFW<T>::DoMainTest(int testIdx)
{
	int i;
	BOOL bSetupSucceeded = TRUE;
	TEST_FUNC fn = NULL;
	TCHAR* pFuncName = NULL;

	////
	// set up
	////

	for (i=0; i<MAX_TEST_FUNC; i++) {
		if (m_TestItems[testIdx].fnSetUp[i]) {
			fn = m_TestItems[testIdx].fnSetUp[i];
			if ( (p->*fn)() ) {
				// Intentionally blank for positive logic.
			} else {
				bSetupSucceeded = FALSE;
				TCHAR* pFuncName1 = NULL;
				TCHAR* pFuncName2 = NULL;
				GetFunctionName(fn, &pFuncName1);
				GetFunctionName(m_TestItems[testIdx].fnMain[0], &pFuncName2);
				MSG_TEST_FAILED((_T("T[%03d] %s: setup function [%s] failed.\r\n"),testIdx,pFuncName2,pFuncName1));

				// mainÇÔ¼ö¸¦ ½ÌÇàÇÑ °Ç ¾Æ´ÏÁö¸¸, setup¿¡ ÇÊ¿äÇÑ ÀÛ¾÷ÀÌ ½ÇÆÐÇßÀ¸¹Ç·Î ÀÌ ÇÔ¼öµµ ½ÇÆÐÇß´Ù°í º»´Ù.
				m_TestItems[testIdx].fTestStatus = TS_TEST_FAILED;
				
				break;
			}
		}
	}

	////
	// main
	////

	if (bSetupSucceeded) {
		fn = m_TestItems[testIdx].fnMain[0];
		if ( (p->*fn)() ) {
			m_TestItems[testIdx].fTestStatus = TS_TEST_OK;
		} else {
			m_TestItems[testIdx].fTestStatus = TS_TEST_FAILED;
		}
	}

	////
	// tear down
	////

	for (i=0; i<MAX_TEST_FUNC; i++) {
		if (m_TestItems[testIdx].fnTearDown[i]) {
			fn = m_TestItems[testIdx].fnTearDown[i];
			(p->*fn)();
		}
	}

	////
	// show test result
	////

	pFuncName = NULL;
	GetFunctionName(fn, &pFuncName);
	if (m_TestItems[testIdx].fTestStatus==TS_TEST_OK) {
		MSG_TEST_OK((_T("T[%03d] %s OK\r\n"),testIdx,pFuncName));
	}
	if (m_TestItems[testIdx].fTestStatus==TS_TEST_FAILED) {
		MSG_TEST_FAILED((_T("T[%03d] %s Failed\r\n"),testIdx,pFuncName));
	}

}

template <class T>
BOOL CTestFW<T>::AddTestItem(int dummy, ...)
{
	union {
		TEST_FUNC	m;
		TEST_MARKER	p;
	} mark;
	va_list marker;
	
	TEST_ITEM testItem = {0,};
	
	// mainÀ» »©°í var arg¸¦ Èȴ´Ù.

	int idxRequired = 0;
	int idxSetup = 0;
	int idxTearDown = 0;
	int idxMain = 0;

	int* pIdx = NULL;
	TEST_FUNC* pFunc = NULL;
	BOOL bExcluded;

	va_start( marker, dummy );
	mark.p = TM_MAIN;
	bExcluded = FALSE;
	while(mark.p != TM_END) {
		mark.m = va_arg( marker, TEST_FUNC);
		switch(mark.p) {
		case TM_MAIN:
			pIdx = &idxMain;
			pFunc = &testItem.fnMain[0]; 
			break;
		case TM_REQUIRED:
			pIdx = &idxRequired;
			pFunc = &testItem.fnRequired[0]; 
			break;
		case TM_SETUP:
			pIdx = &idxSetup;
			pFunc = &testItem.fnSetUp[0]; 
			break;
		case TM_TEARDOWN:
			pIdx = &idxTearDown;
			pFunc = &testItem.fnTearDown[0]; 
			break;
		case TM_EXCLUDE:
			bExcluded = TRUE;
			break;
		case TM_END:
			break;
		default:
			if (mark.p!=TM_END) {
				pFunc[*pIdx] = mark.m;
				(*pIdx)++;
			}
			break;
		}
	}
	va_end( marker );

	if (bExcluded) {
		m_nCurrentItemNumber++;
		return TRUE;
	}

	// var arg Áß¿¡¼­ main¸¸ ã´Â´Ù.

	// ¹Ýµå½Ã mainÀÌ ÀÖ¾î¾ß ÇÑ´Ù°í °¡Á¤ÇÑ´Ù. mainÀÌ ¾øÀ¸¸é, ÇÁ·Î±×·¥ ¿À·ù°¡ ¹ß»ýÇÑ´Ù.

	ZeroMemory(testItem.fnMain, sizeof(testItem.fnMain));

	va_start( marker, dummy );
	mark.p = TM_MAIN;
	while(mark.p != TM_END) {
		mark.m = va_arg( marker, TEST_FUNC);
		if (mark.p==TM_MAIN) {
			break;
		}
	}
	ASSERT(mark.p==TM_MAIN);
	while(mark.p != TM_END) {
		mark.m = va_arg( marker, TEST_FUNC);
		if (mark.p==TM_MAIN||mark.p==TM_REQUIRED||mark.p==TM_SETUP||mark.p==TM_TEARDOWN||mark.p==TM_EXCLUDE||mark.p==TM_END) {
			break;
		}
		testItem.fnMain[0] = mark.m;
		testItem.nItemNumber = m_nCurrentItemNumber;
		AddTestItem(&testItem);
	}

	va_end( marker );

	m_nCurrentItemNumber++;
	return TRUE;
}

template <class T>
BOOL CTestFW<T>::AddTestItem(TEST_ITEM* pItem)
{
	ASSERT(m_cTestItems<MAX_TEST_ITEMS);

	m_TestItems[m_cTestItems] = *pItem;

	m_TestItems[m_cTestItems].fTestStatus = TS_NOT_TESTED;

	m_cTestItems++;

	return TRUE;
}

template <class T>
BOOL CTestFW<T>::GetFunctionName(TEST_FUNC fn, TCHAR** ppFuncName)
{
	*ppFuncName = NULL;
	for (int k=0; k<m_cFuncName; k++) {
		if (m_FuncName[k].fnFunc==fn) {
			*ppFuncName = m_FuncName[k].sName;
			return TRUE;
		}
	}

	return FALSE;
}

template <class T>
void CTestFW<T>::ShowDuplicatedTest()
{
	TEST_FUNC fn1, fn2;
	for (int i=0; i<m_cFuncName;i++) {
		fn1 = m_TestItems[i].fnMain[0];
		if (fn1!=0) {
			for (int j=i+1; j<m_cFuncName; j++) {
				fn2 = m_TestItems[j].fnMain[0];
				if (fn1==fn2) {
					TCHAR* pFuncName = NULL;
					GetFunctionName(fn1, &pFuncName);
					MSG_TEST_NOTE((_T("T[%03d] %s is duplicated. Is this intended?\r\n"),j,pFuncName));
					break;
				}
			}
		}
	}
}

template <class T>
BOOL CTestFW<T>::CheckWhetherAllTestFunctionNameAreRegistered()
{
#define IS_NAME_EXIST(fieldName, field)	\
	if (field) {\
		if (!GetFunctionName(field, &pFuncName)) {\
			MSG_TEST_NOTE((_T("Test item [%d] [%s] contains function which has not registered its function name.\r\n"),m_TestItems[i].nItemNumber,fieldName));\
			rs = FALSE;\
		}\
	}

	TCHAR* pFuncName = NULL;
	BOOL rs = TRUE;
	for (int i=0; i<m_cFuncName;i++) {
		for (int j=0; j<MAX_TEST_FUNC; j++) {
			IS_NAME_EXIST("Required", m_TestItems[i].fnRequired[j]);
			IS_NAME_EXIST("Set up", m_TestItems[i].fnSetUp[j]);
			IS_NAME_EXIST("Main", m_TestItems[i].fnMain[j]);
			IS_NAME_EXIST("Tear down", m_TestItems[i].fnTearDown[j]);
		}
	}

#undef IS_NAME_EXIST

	return rs;
}