tpltest.cpp

wince5.0 pb中pccard源码

	delete[] pOrder;

	return TRUE;
}

#define TEST_THREAD_NUMBER	4
BOOL TplTest::Test_MT_ReadAllTuples(){

 	HANDLE	hSubThread[TEST_THREAD_NUMBER] = {0};
	UINT8	i;
	BOOL      bRet = TRUE;
	//Launch threads
	for(i = 0; i < TEST_THREAD_NUMBER; i ++){
		THREAD_PARMS TParms = {this, (UINT8)i };
		hSubThread[i] = ::CreateThread(NULL, 0, TplTest::ReadTuplesSubThread, (LPVOID)&TParms, 0, NULL);
		if (hSubThread[i] == NULL) {
			g_pKato->Log(LOG_DETAIL,TEXT("Thread %d, Sock %u Func %u, create thread failed\r\n"),
								m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
			bRet = FALSE;
			break;
		}
    	}

	//close threads
	for(i = 0; i < TEST_THREAD_NUMBER; i ++){
		if(hSubThread[i] != NULL){
        		WaitForSingleObject(hSubThread[i], INFINITE);
			CloseHandle(hSubThread[i]);
		}
    	}

	return bRet;
	
}

DWORD
WINAPI
TplTest::ReadTuplesSubThread(LPVOID dParam){
	DEBUGCHK(dParam != NULL);
	PTHREAD_PARMS pThreadPtr = (PTHREAD_PARMS)dParam;
	TplTest* pTplTestPtr = pThreadPtr->pTplTest;
	DWORD exitCode=pTplTestPtr-> RunReadTuplesSubThreadProc(pThreadPtr->uSubID);
	::ExitThread(exitCode);
	return exitCode;
}

DWORD
TplTest::RunReadTuplesSubThreadProc(UINT8 uSubID){
	INT* pOrder = NULL;
	PTPLCONTENT pNewTplContent = NULL;

	pOrder = new INT[TOTAL_VALID_TUPLECODES+1];
	pNewTplContent = new TPLCONTENT[TOTAL_VALID_TUPLECODES+1];
	if(pNewTplContent == NULL || pOrder == NULL){
        	g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> out fo memory  -- Thread%d, Socket %u Func %u, SubThread %d\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc, uSubID);
		SetResult(FALSE);
             if(pOrder != NULL)
                 delete[] pOrder;
             if(pNewTplContent != NULL)
        	    delete[] pNewTplContent;
		return -1;
	}
	memset(pNewTplContent, 0, sizeof(TPLCONTENT)*(TOTAL_VALID_TUPLECODES+1));

	INT j = 1;
	if(GenRandomOrder(&pOrder[1], TOTAL_VALID_TUPLECODES) == FALSE){
        	g_pKato->Log(LOG_DETAIL,TEXT("Thread%d, Socket %u Func %u, SubThread %d, can not create a random order\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc, uSubID);
		SetResult(FALSE);
        	delete[] pOrder;
        	delete[] pNewTplContent;
		return -1;
	}
	
	//read tuples out
	if(ReadAllTuples(pNewTplContent, pOrder) == FALSE){
        	g_pKato->Log(LOG_DETAIL,TEXT("Thread%d, Socket %d, SubThread %u Func %u, Read all tuples failed using alternative order\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc, uSubID);
		SetResult(FALSE);
        	delete[] pOrder;
        	delete[] pNewTplContent;
		return -1;
	}

	//compare with the default content structure
	if(AreTwoTupleContentsIdentical(m_pTplContents, pNewTplContent) == FALSE){
        	g_pKato->Log(LOG_DETAIL,TEXT("Thread%d, Socket %d, SubThread %u Func %u compare results of two reads failed\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc, uSubID);
		SetResult(FALSE);
        	delete[] pOrder;
        	delete[] pNewTplContent;
		return -1;
	}

	CleanupTupleContents(pNewTplContent);
	delete[] pOrder;

	return 0;


}

BOOL TplTest::GenRandomOrder(INT* pArr, UINT uLen){
	if(pArr == NULL || uLen == 0)
		return FALSE;
	
	UINT* pHit = new UINT[uLen];
	if(pHit == NULL)
		return FALSE;
	memset(pHit, 0, sizeof(UINT)*uLen);
	for(UINT i = 0; i < uLen; i++){
		UINT uTemp;
		do{
			uTemp = (UINT)rand();
			uTemp = (uTemp % uLen) + 1;
		}while(pHit[uTemp-1] == 1);
		pArr[i] = uTemp;
		pHit[uTemp-1] = 1;
	}

	return TRUE;

}

BOOL TplTest::AddiTst_GetFirstTuple(){
	PCARD_TUPLE_PARMS	m_pTuple = NULL;
	STATUS				status;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("+ TplTest::AddiTst_GetFirstTuple() enterted\r\n")));

	//test 1: input null parameter
	if((status =::CardGetFirstTuple(NULL)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetFirstTuple: Thread %d, Sock %u Func %u, Null input, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
		return FALSE;
	}
	
	m_pTuple = (PCARD_TUPLE_PARMS) new CARD_TUPLE_PARMS;
	if(m_pTuple == NULL){
		NKDbgPrintfW(_T("not enough memory!"));
		return FALSE;
	}
	m_pTuple->uDesiredTuple = CISTPL_END; //that means any tuple
	m_pTuple->fAttributes = 1;

	//test 2:input wrong socket number
	(m_pTuple->hSocket).uSocket = m_uLocalSock + TEST_MAX_CARDS;//wrong socket number
	(m_pTuple->hSocket).uFunction = 0;
	if((status =::CardGetFirstTuple(m_pTuple)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetFirstTuple: Thread %d, Sock %u Func %u, wrong socket number, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc);
		delete m_pTuple;
		return FALSE;
	}
	(m_pTuple->hSocket).uSocket = (UCHAR)m_uLocalSock;
	(m_pTuple->hSocket).uFunction = 0xFF; //wrong function number
	if((status =::CardGetFirstTuple(m_pTuple)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetFirstTuple: Thread %d, Sock %u Func %u, wrong function number, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc);
		delete m_pTuple;
		return FALSE;
	}

	delete m_pTuple;
	DEBUGMSG(ZONE_FUNCTION, (TEXT("- TplTest::AddiTst_GetFirstTuple()\r\n")));
	
	return TRUE;
}


BOOL TplTest::AddiTst_GetNextTuple(){
	PCARD_TUPLE_PARMS	m_pTuple = NULL;
	STATUS				status;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("+ TplTest::AddiTst_GetNextTuple() enterted\r\n")));

	//test 1: input null parameter
	if((status =::CardGetNextTuple(NULL)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetNextTuple: Thread %d, Sock %u Func %u, Null input, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
		return FALSE;
	}
	
	m_pTuple = (PCARD_TUPLE_PARMS) new CARD_TUPLE_PARMS;
	if(m_pTuple == NULL){
		NKDbgPrintfW(_T("not enough memory!"));
		return FALSE;
	}
	m_pTuple->uDesiredTuple = CISTPL_END; //that means any tuple
	m_pTuple->fAttributes = 1;
	(m_pTuple->hSocket).uSocket = (UCHAR)m_uLocalSock;
	(m_pTuple->hSocket).uFunction = (UCHAR)m_uLocalFunc;
	if((status =::CardGetFirstTuple(m_pTuple)) != CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetFirstTuple: Thread %d, Sock %u Func %u,  FAILed, ret = 0x%x\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc, status) ;
		delete m_pTuple;
		return FALSE;
	}

	//test 2:input with wrong hsocket info 
	(m_pTuple->hSocket).uSocket = m_uLocalSock + TEST_MAX_CARDS;//wrong socket number
	if((status =::CardGetNextTuple(m_pTuple)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetNextTuple: Thread %d, Sock %u Func %u, wrong socket number, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
		delete m_pTuple;
		return FALSE;
	}
	(m_pTuple->hSocket).uSocket = (UCHAR)m_uLocalSock;
	(m_pTuple->hSocket).uFunction = 0xFF; //wrong function number
	if((status =::CardGetNextTuple(m_pTuple)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetNextTuple: Thread %d, Sock %u Func %u, wrong function number, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
		delete m_pTuple;
		return FALSE;
	}

	delete m_pTuple;
	DEBUGMSG(ZONE_FUNCTION, (TEXT("- TplTest::AddiTst_GetNextTuple()\r\n")));
	
	return TRUE;
}


#define BUF_SIZE		4096	//for holding the data in tuple

BOOL TplTest::AddiTst_GetTupleData(){

	BYTE  				*buf = NULL;
	STATUS				status;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("+ TplTest::AddiTst_GetTupleData() enterted\r\n")));
	buf = (PBYTE)malloc(BUF_SIZE);
	if(buf == NULL){
		g_pKato->Log(LOG_DETAIL,TEXT("-->TplTest::AddiTst_GetTupleData<--   FAIL -- out of memory\r\n")); 
		return FALSE;
	}

	PCARD_TUPLE_PARMS	m_pTuple = (PCARD_TUPLE_PARMS)buf;
	PCARD_DATA_PARMS	m_pData = (PCARD_DATA_PARMS)buf;
	
	//test 1: input null parameter
	if((status =::CardGetTupleData(NULL)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetTupleData: Thread %d, Sock %u Func %u, Null input, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
		free(buf);
		return FALSE;
	}
	
	m_pTuple->uDesiredTuple = CISTPL_END; //that means any tuple
	m_pTuple->fAttributes = 1;
	(m_pTuple->hSocket).uSocket = (UCHAR)m_uLocalSock;
	(m_pTuple->hSocket).uFunction = (UCHAR)m_uLocalFunc;
	if((status =::CardGetFirstTuple(m_pTuple)) != CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetFirstTuple: Thread %d, Sock %u Func %u,  FAILed, ret = 0x%x\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc, status) ;
		free(buf);
		return FALSE;
	}

	m_pData->uBufLen = BUF_SIZE - sizeof(CARD_DATA_PARMS);
	m_pData->uTupleOffset = 0;
	
	//test 2:input with wrong hsocket info 
	(m_pTuple->hSocket).uSocket = m_uLocalSock + TEST_MAX_CARDS;//wrong socket number
	if((status =::CardGetTupleData(m_pData)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetTupleData: Thread %d, Sock %u Func %u, wrong socket number, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
		free(buf);
		return FALSE;
	}
	(m_pTuple->hSocket).uSocket = (UCHAR)m_uLocalSock;
	(m_pTuple->hSocket).uFunction = 0xFF; //wrong function number
	if((status =::CardGetTupleData(m_pData)) == CERR_SUCCESS) {
		g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetTupleData: Thread %d, Sock %u Func %u, wrong function number, should NOT return CERR_SUCCESS\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
		free(buf);
		return FALSE;
	}

	free(buf);
	DEBUGMSG(ZONE_FUNCTION, (TEXT("- TplTest::AddiTst_GetTupleData()\r\n")));
	
	return TRUE;
}

//--------------Helper functions -----------------------------
TCHAR *findStr (CISStrings *is, UINT32 n){
    	if (n > 0xFFU) 
    		return 0 ;
    	for (unsigned int i = 0 ; is[i].index < n ; i++) ;
    	return (n == is[i].index) ? is[i].text : 0 ;
}

TCHAR *findTupleNameStr (UINT32 n){
    	if (n > 0xFFU) return 0 ;
    	for (unsigned int i = 0 ; TupleCodes[i].index < n ; i++) ;
    	return (n == TupleCodes[i].index) ? TupleCodes[i].text : 0 ;
  }

TCHAR *findTupleNameStrEx (UINT32 n){
    	TCHAR *p = findTupleNameStr (n) ;
    	return p ? p : TEXT("Unknown") ;
}

int requiredSupport (CISStrings *is, unsigned int n){ // then & with CARD_IO or CARD_MEMORY
    	if (n > 0xFFU) return 0 ;
    	for (unsigned int i = 0 ; is[i].index < n ; i++) ;
    	return (n == is[i].index) ? is[i].cardTypesSupportingTuple : 0 ;
}

int numberOfTupleCodes () {return 33; }//sizeof(TupleCodes)/sizeof(CISStrings) ;}

long possibleReturns [6] =
{
    CERR_SUCCESS,         // 0x00
    CERR_READ_FAILURE,    // 0x09
    CERR_BAD_SOCKET,      // 0x0B  hSocket does not name a socket
    CERR_BAD_ARGS,        // 0x1C  if pParms == 0
    CERR_NO_MORE_ITEMS,   // 0x1F
    CERR_OUT_OF_RESOURCE  // 0x20  no window is mapped to attribute space on this socket
} ;

int isPossibleReturn (long n){
    	for (int i = 0 ; i < 6 ; i++) if (n == possibleReturns[i]) return 1 ;
    	return 0 ;
}

TCHAR *MatchedString [] =
{
    TEXT("Status"),
    TEXT("Tuple Code"),
    TEXT("Tuple Link (length)"),
    TEXT("Data Length"),
    TEXT("Date")
} ;

TCHAR *findMatchedStringAt (int n){
    	if (n >= (sizeof(MatchedString)/sizeof(TCHAR*))) 
    		return TEXT("") ;
    	return MatchedString [n] ;
}