tpltest.cpp

wince5.0 pb中pccard源码

//******************************************************************************
//
//
// This source code is licensed under Microsoft Shared Source License
// Version 1.0 for Windows CE.
// For a copy of the license visit http://go.microsoft.com/fwlink/?LinkId=3223.
//******************************************************************************
/*++
Module Name:  
	Tpltest.cpp

Abstract:

    Tests related with tuple-related functions

--*/

#include "testmain.h"
#include "common.h"
#include "scardtpl.h"
#include "TplTest.h"

BOOL
TplTest::Init(){
	LPTPLTESTPARAMS  lparm = NULL;

	if(m_dwCaseID > 100){
		lparm = &tplarr[0];
	}
	else {
		lparm = &tplarr[m_dwCaseID-1];
	}
	
	m_nSeed = lparm->nSeed;
	m_nTrials = lparm->nTrials;

	m_pMatchedCard = NULL;

	m_pTplContents = NULL;
	m_pTplContents = new TPLCONTENT[TOTAL_VALID_TUPLECODES+1];
	if(m_pTplContents == NULL){
        	g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> out fo memory  -- Thread%u, Socket %u Funciton %u\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc);
		return FALSE;
	}

	memset(m_pTplContents, 0, sizeof(TPLCONTENT)*(TOTAL_VALID_TUPLECODES+1));
	if(ReadAllTuples(m_pTplContents, NULL) == FALSE){
        	g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> Failed to read out all tuples on this card  -- Thread%d, Socket %d Funciton %u\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc);
		return FALSE;
	}
	
	return TRUE;
}

DWORD TplTest::ThreadRun() {

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

	//Some specail test cases are designed in order to cover some code which can not be covered 
	//by those nomral test cases.
	switch(m_dwCaseID){
		case 1:
			if(Test_ReadAllTuples() == FALSE){
				SetResult(FALSE);
			}
			goto CLEANUP;
		case 2:
			if(Test_MT_ReadAllTuples() == FALSE){
				SetResult(FALSE);
			}
			goto CLEANUP;
		case 101://additional test for "CardGetFirstTuple"
			if(AddiTst_GetFirstTuple() == FALSE){
				SetResult(FALSE);
			}
			goto CLEANUP;
		case 102://additional test for "CardGetNextTuple"
			if(AddiTst_GetNextTuple() == FALSE){
				SetResult(FALSE);
			}
			goto CLEANUP;
		case 103://additional test for "CardGetTupleData"
			if(AddiTst_GetTupleData() == FALSE){
				SetResult(FALSE);
			}
			goto CLEANUP;
		default: //normal test cases
			break;
	}
	
CLEANUP:

	if(m_pTplContents)
		CleanupTupleContents(m_pTplContents);
	
	DEBUGMSG(ZONE_FUNCTION, (TEXT("- TplTest::ThreadRun()\r\n")));
	
	return 0;
}

BOOL TplTest::ReadAllTuples(PTPLCONTENT pTpls, INT *pOrder){

	
	if(pTpls == NULL)
		return FALSE;

	for(int i = 1; i <= TOTAL_VALID_TUPLECODES; i++){
		if(GetOneTypeTuples(pTpls, (pOrder == NULL)?i:pOrder[i]) == FALSE){
			return FALSE;
		}
	}

	return TRUE;
}

BOOL TplTest::GetOneTypeTuples(PTPLCONTENT pTpls, INT loc){

	CARD_TUPLE_PARMS	TupleParms;
	STATUS	status;
		
	if(pTpls == NULL)
		return FALSE;

	UINT8 uNextTplCode = TupleCodes[loc].index;
	pTpls[loc].uTplCode = uNextTplCode;
	
	//find the first tuple
	TupleParms.fAttributes = 0xFF;
	TupleParms.uDesiredTuple = uNextTplCode;
	TupleParms.hSocket.uFunction = (UINT8)m_uLocalFunc;
	TupleParms.hSocket.uSocket = (UINT8)m_uLocalSock;

	status = ::CardGetFirstTuple(&TupleParms);
	if(status != CERR_SUCCESS){
		if(status == CERR_NO_MORE_ITEMS){//no items found
			return TRUE;
		}
		else{
	        	g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u Funciton %u--CardGetFirstTuple returned %s\r\n"),
	          							m_dwThreadID, m_uLocalSock, m_uLocalFunc, FindStatusName(status)) ;
	        	return FALSE;
		}
	}

	do{
		//get data from this tuple
	    	UINT16 size = TupleParms.uTupleLink + sizeof (CARD_DATA_PARMS) ;
	    	if (!size || (size < sizeof(CARD_TUPLE_PARMS))) 
	    		return FALSE ;

	    	PCARD_DATA_PARMS q = (PCARD_DATA_PARMS) new UCHAR [size] ;
	    	if (!q) 
	    		return FALSE;
			
	    	memset (q, 0, size) ;
	    	memcpy (q, &TupleParms, sizeof (CARD_TUPLE_PARMS)) ;
	    	q->uBufLen = TupleParms.uTupleLink ;
	    	q->uDataLen = 0 ;
	    	q->uTupleOffset = 0 ; 
		if(::CardGetTupleData(q) != CERR_SUCCESS){
	        	g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u Funciton %u--CardGetTupleData returned %s\r\n"),
	          							m_dwThreadID, m_uLocalSock, m_uLocalFunc, FindStatusName(status)) ;
			return FALSE;
		}

		//create instance to hold the data
		SCardTuple *pNode = new SCardTuple(TupleParms.uTupleCode, TupleParms.uTupleLink, q); 
		if(pNode == NULL){
			return FALSE;
		}

		//add it to the link list
		SCardTuple* sCurrent = pTpls[loc].sTplHead;
		if(sCurrent == NULL){//this is the head
			pTpls[loc].sTplHead = pNode;
		}
		else{
			while(sCurrent->link != NULL){
				sCurrent = sCurrent->link;
			}
			sCurrent->link = pNode;		
		}
		pTpls[loc].uNumofTpls ++;

		DEBUGMSG(ZONE_VERBOSE, (TEXT("Tuple %s, add one tuple.\r\n"), TupleCodes[loc].text));
		
		status = ::CardGetNextTuple(&TupleParms);
		if(status == CERR_NO_MORE_ITEMS)//done
			return TRUE;
		else if(status != CERR_SUCCESS){
	        	g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u Funciton %u--CardGetNextTuple returned %s\r\n"),
	          							m_dwThreadID, m_uLocalSock, m_uLocalFunc, FindStatusName(status)) ;
			return FALSE;
		}
	}while(TRUE);

	return TRUE;
	
}

VOID TplTest::CleanupTupleContents(PTPLCONTENT pTplContents){

	if(pTplContents == NULL)
		return;

	//delete each link list
	for(int i = 0; i <= TOTAL_VALID_TUPLECODES; i++){
		if(&(pTplContents[i]) == NULL)//ah, end here
			return;
		SCardTuple* sCurNode = pTplContents[i].sTplHead;
		if(sCurNode == NULL)
			continue;
		SCardTuple* sNextNode = sCurNode->link;
		while(sNextNode != NULL){
			delete sCurNode;
			sCurNode = sNextNode;
			sNextNode = sNextNode->link;
		}
	}

	delete[] pTplContents;
	pTplContents = NULL;
}


BOOL TplTest::AreTwoTupleContentsIdentical(PTPLCONTENT pTpl1, PTPLCONTENT pTpl2){

	if((pTpl1 == NULL) || (pTpl2 == NULL)){
		g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u--Bad args for AreTwoTupleContentsEqual() call\r\n"),
		                                                m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
		return FALSE;
	}

	for(int i = 0; i <=TOTAL_VALID_TUPLECODES; i++){
		if(&(pTpl1[i])  == NULL || &(pTpl2[i]) == NULL){
			g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u--Bad args for AreTwoTupleContentsEqual() call\r\n"),
			                    m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
			return FALSE;
		}

		//two tuplecode should be the same in any cases
		ASSERT(pTpl1[i].uTplCode == pTpl2[i].uTplCode);

		// the number of tuples of the same tuple code should be the same
		if(pTpl1[i].uNumofTpls != pTpl2[i].uNumofTpls){
			g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u--number of tuples for %s: %d != %d\r\n"),
							m_dwThreadID, m_uLocalSock, m_uLocalFunc, TupleCodes[i].text, pTpl1[i].uNumofTpls, pTpl2[i].uNumofTpls) ;
			return FALSE;
		}

		SCardTuple *p = pTpl1[i].sTplHead;
		SCardTuple *q = pTpl2[i].sTplHead;
		for(int j = 0; j < pTpl1[i].uNumofTpls; j++){
			if(p == NULL || q == NULL){
				g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u--some tuple for %s is missing!\r\n"),
								m_dwThreadID, m_uLocalSock, m_uLocalFunc, TupleCodes[i].text) ;
				return FALSE;
			}

			//compare tuple code
			if(p->uTupleCode != q->uTupleCode){
				g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u-- tuple code %d != %d!\r\n"),
								m_dwThreadID, m_uLocalSock, m_uLocalFunc, p->uTupleCode, q->uTupleCode) ;
				return FALSE;
			}
			//compare data length
			if(p->uTupleLink != q->uTupleLink){
				g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u-- date len %d != %d!\r\n"),
								m_dwThreadID, m_uLocalSock, m_uLocalFunc, p->uTupleLink, q->uTupleLink) ;
				return FALSE;
			}
			//compare data
			PBYTE x = (PBYTE)(p->pTupleData); 
			PBYTE y = (PBYTE)(q->pTupleData);
			if(memcmp(x, y, p->uTupleLink)){
				g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u-- two tuples' data is not identical\r\n"),\
				                                                m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
				p->dump();
				q->dump();
				return FALSE;
			}
			//compare parsed data, if it exists
			if(p->nParsedItems == 0 && q->nParsedItems == 0){//no parsed data, goto next tuple
				p = p->link;
				q = q->link;
				continue;
			}
			//compare number of parsed items
			if(p->nParsedItems != q->nParsedItems){
				g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u-- number of parsed items %d != %dl\r\n"),
										m_dwThreadID, m_uLocalSock, m_uLocalFunc, p->nParsedItems, q->nParsedItems) ;
				p->dump();
				q->dump();
				return FALSE;
			}
			//compare parsed buffer length
			if(p->parsedSize != q->parsedSize){
				g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u-- length of parsed buffer %d != %dl\r\n"),
										m_dwThreadID, m_uLocalSock, m_uLocalFunc, p->parsedSize, q->parsedSize) ;
				p->dump();
				q->dump();
				return FALSE;
			}
			//compare parsed buffer
			x = (PBYTE)p->parsedBuf;
			y = (PBYTE)q->parsedBuf;
			if(memcmp(x, y, p->parsedSize)){
				g_pKato->Log(LOG_DETAIL,TEXT("Thread %u, Socket %u, Function %u-- two tuples' data is not identical\r\n"),
				                                       m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
				p->dump();
				q->dump();
				return FALSE;
			}

			p = p->link;
			q = q->link;
		}

	}
	
	return TRUE;
}

VOID TplTest::ResetCardTupleParms (){
    	// Initialize the data in pTuple.
    	(m_pTuple->hSocket).uSocket = (UCHAR)m_uLocalSock ;
    	(m_pTuple->hSocket).uFunction = (UCHAR)m_uLocalFunc ;
    	m_pTuple->fAttributes = 0xFF ;
    	m_pTuple->uDesiredTuple = CISTPL_CONFIG; //0xFF ;
    	m_pTuple->uReserved = 0 ;
    	m_pTuple->fFlags = 0 ;
    	m_pTuple->uLinkOffset = 0 ;
    	m_pTuple->uCISOffset = 0 ;
    	m_pTuple->uTupleCode = 0 ;
    	m_pTuple->uTupleLink = 0 ;
    
    	// Finish initializing pMatchedCard.