tpltest.cpp

wince5.0 pb中pccard源码

    	STATUS status  = CERR_SUCCESS;
	UINT   iTry;

	for (iTry = 0; iTry < MAX_TRY; iTry++){
		status = ::CardGetFirstTuple(m_pTuple);
		if (status != CERR_READ_FAILURE)  		           // In multi threads situation
			break;
		Sleep (1000);
	}

	m_lastCalled = (status == CERR_SUCCESS) ? LAST_FIRST : LAST_NONE ;


    	// out the unreported return from this ::CardGetFirstTuple call.
    	if (m_lastCalled == LAST_NONE){
        	if (status < 0) status = 0 ;
        	if (status > 0x23) status = 0x23 ;
        	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)) ;
        	SetResult(FALSE);
      }
}

VOID TplTest::MakeACall (){

    	if (m_lastCalled == LAST_NONE)
    		ResetCardTupleParms () ;
    	if (m_lastCalled == LAST_NONE){//failed
        	g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> Could not reset CARD_TUPLE_PARMS  -- Thread%u, Socket %u\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc);
        	SetResult(FALSE);
        	return;
      }

	UINT uRandNo =	2;// ((UINT) rand()) % 4;
    	switch (uRandNo){//exercise one of the following functionality
        	case 0: 
        		CardGetFirstTuple () ;  
        		break ;
        	case 1: 
        		CardGetNextTuple () ;   
        		break ;
        	case 2: 
        		CardGetTupleData () ;   
        		break ;
        	case 3: 
        		CardGetParsedTuple () ; 
        		break ;
        	default: break ;
      	}
}

VOID TplTest::DumpCurrentErrors (){

	TCHAR *softStr;
	TCHAR *hardStr;

	UINT32 w, x, y ; 
	m_pMatchedCard->getMismatchedParams (&w, &x, &y) ;

    	switch (w){
        	case 0: // STATUS
          		g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> Soft status: %s  --  Hard status: %s -- Thread%d, Sock %d, Func %d\r\n"),
              							FindStatusName(x), FindStatusName(y), m_dwThreadID, m_uLocalSock, m_uLocalFunc);
          		SetResult(FALSE);
          		break;

        	case 1: // Tuple code
          		softStr = findTupleNameStrEx (x) ;
          		hardStr = findTupleNameStrEx (y) ;
          		g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> Soft card code: %s  --  Hard card code: %s -- Thread%d, Sock %d, Func %d\r\n"),
              							softStr, hardStr, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
          		SetResult(FALSE);
          		break ;

        	case 2: // Tuple Link
          		g_pKato->Log(LOG_DETAIL,TEXT("FAILED  --> Soft tuple link: %ld  --  Hard tuple link: %ld -- Thread%d, Sock %d, Func %d\r\n"),
              							x, y, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
          		SetResult(FALSE);
          		break ; 

        	case 3: // Data Length
          		g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> Soft data length: %ld  --  Hard data length: %ld -- Thread%d, Sock %d, Func %d\r\n"),
              							x, y, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
          		SetResult(FALSE);
          		break ; 

        	case 4: // Data mismatch
          		g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> Tuple data does not match -- Both lengths: %ld -- Thread%d, Sock %d, Func %d\r\n"),
              							x, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
          		SetResult(FALSE);
          		break ; 

        	case 5: // Extra data bytes set.
          		g_pKato->Log(LOG_DETAIL,TEXT("FAILED --> The tuple has %ld extra bytes -- Thread%d, Sock %d, Func %d\r\n"),
              							y, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
          		SetResult(FALSE);
          		break ; 

        	default: // No errors
          		g_pKato->Log(LOG_DETAIL,TEXT("PASSED -- Thread%d, Sock %d Func %d\r\n"),
              							m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
          		break ; 
      }

}

VOID TplTest::CardGetFirstTuple (){
	UINT uRandNo = ((UINT)rand()) %2;
    	m_pTuple->fAttributes = uRandNo;
    	uRandNo = ((UINT)rand()) % numberOfTupleCodes();
    	m_pTuple->uDesiredTuple = TupleCodes[uRandNo].index ;

    	TCHAR *desStr = findTupleNameStrEx (m_pTuple->uDesiredTuple) ;
    	TCHAR *linkMsg = (m_pTuple->fAttributes & 1) ? TEXT("accept links") : TEXT("skip links") ;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("+ TplTest::CardGetFirstTuple() enterted\r\n")));
    	g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetFirstTuple: %s  --  Desired: %s -- Thread%d Sock %d Func %d\r\n"),
    							linkMsg, desStr, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;

    	STATUS status = m_pMatchedCard->CardGetFirstTuple (m_pTuple) ;

	m_lastCalled = (status == CERR_SUCCESS) ? LAST_FIRST : LAST_NONE ;
	if(m_pTuple->uDesiredTuple == CISTPL_NULL || m_pTuple->uDesiredTuple == CISTPL_LONGLINK_A ||m_pTuple->uDesiredTuple == CISTPL_LONGLINK_C){
		m_lastCalled = LAST_NONE; //force to reset
		DEBUGMSG(ZONE_VERBOSE, (TEXT("Reset tuple\r\n")));

	}
	DEBUGMSG(ZONE_FUNCTION, (TEXT("- TplTest::CardGetFirstTuple()\r\n")));

}

VOID TplTest::CardGetNextTuple (){
	UINT uRandNo = ((UINT)rand()) %2;
    	m_pTuple->fAttributes = uRandNo;
    	uRandNo = ((UINT)rand()) % numberOfTupleCodes();
    	m_pTuple->uDesiredTuple = TupleCodes[uRandNo].index ;

    	TCHAR *desStr = findTupleNameStrEx (m_pTuple->uDesiredTuple) ;
    	TCHAR *linkMsg = (m_pTuple->fAttributes & 1) ? TEXT("accept links") : TEXT("skip links") ;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("+ TplTest::CardGetNextTuple() enterted\r\n")));
    	g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetNextTuple: %s  --  Desired: %s -- Thread%d Sock %d Func %d\r\n"),
    							linkMsg, desStr, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;

    	STATUS status  = CERR_SUCCESS;

	for (UINT iTry = 0; iTry < MAX_TRY; iTry++){
		status = m_pMatchedCard->CardGetNextTuple (m_pTuple);
		if (status != CERR_READ_FAILURE)  		           // In multi threads situation
				break;
		Sleep (1000);
	}

    	m_lastCalled = (status == CERR_SUCCESS) ? LAST_NEXT  : LAST_NONE ;
	if(m_pTuple->uDesiredTuple == CISTPL_NULL || m_pTuple->uDesiredTuple == CISTPL_LONGLINK_A ||m_pTuple->uDesiredTuple == CISTPL_LONGLINK_C){
		m_lastCalled = LAST_NONE; //force to reset
		DEBUGMSG(ZONE_VERBOSE, (TEXT("Reset tuple\r\n")));
	}
	DEBUGMSG(ZONE_FUNCTION, (TEXT("- TplTest::CardGetNextTuple()\r\n")));

  }

VOID TplTest::CardGetTupleData (){

    	// Because of resetCardTupleParms() in makeACall()
    	// m_pTuple->uTupleCode and m_pTuple->uTupleLink are set. We need to
    	// use these values before guaranteePresence (m_pTuple)

    	UINT8 tplLength       = m_pTuple->uTupleLink ;
    	UINT8 uDesiredTuple   = m_pTuple->uTupleCode ;
    	m_pData->uDesiredTuple  = uDesiredTuple ;
    	TCHAR *desStr         = findTupleNameStrEx (m_pData->uDesiredTuple) ;

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

    	// This might destroy m_pTuple->uTupleCode and m_pTuple->uTupleLink. (should not)
    	m_pMatchedCard->guaranteePresence (m_pTuple) ;

    	// uTupleOffset is the amount of the tuple to skip at the start.
    	m_pData->uTupleOffset = ((UINT)rand()) % (1+tplLength) ; // 0 <= offset <= tplLength
    	m_pData->uBufLen      = ((UINT)rand()) % (1+2*tplLength) ; // Maximum = 512
	m_pData->uCISOffset = m_pTuple->uCISOffset;
	m_pData->uLinkOffset = m_pTuple->uLinkOffset;
	DEBUGMSG(ZONE_VERBOSE, (TEXT("cisoff: %d, linkoff:%d"), m_pData->uCISOffset, m_pData->uLinkOffset));

    	// We left m_pTuple->fFlags and m_pTuple->uCISOffest alone because
    	// we do not wish to change places. Since we got here,

    	g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetTupleData: Tuple type: %s  -- Offset: %d -- BufLen: %d -- Thread%d, Sock %d, Func %d\r\n"),
        						desStr, m_pData->uTupleOffset, m_pData->uBufLen, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;

    	m_pMatchedCard->CardGetTupleData (m_pData, MAX_PCARD_DATA_PARMS) ;
    	m_lastCalled = LAST_NONE ;
	DEBUGMSG(ZONE_FUNCTION, (TEXT("- TplTest::CardGetTupleData()\r\n")));

}

VOID TplTest::CardGetParsedTuple (){
	UINT  iTry;
	UINT  status;
    	CARD_SOCKET_HANDLE hSocket = {(UCHAR)m_uLocalSock, (UCHAR)m_uLocalFunc} ;

    	UINT8 uDesiredTuple = (((UINT)rand()) % 2) ? CISTPL_CONFIG : CISTPL_CFTABLE_ENTRY ;

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

    	// Guarantee presence if it is needed.
    	(m_pTuple->hSocket).uSocket = (UCHAR)m_uLocalSock ;
    	(m_pTuple->hSocket).uFunction = (UCHAR)m_uLocalFunc ;
    	m_pTuple->fAttributes = 0xFF ;
    	m_pTuple->uDesiredTuple = uDesiredTuple ;
    	m_pTuple->uReserved = 0 ;
    	m_pTuple->fFlags = 0 ;
    	m_pTuple->uLinkOffset = 0 ;
    	m_pTuple->uCISOffset = 0 ;
    	m_pTuple->uTupleCode = 0 ;
    	m_pTuple->uTupleLink = 0 ;
	for (iTry = 0; iTry < MAX_TRY; iTry++){
       	status = ::CardGetFirstTuple(m_pTuple);
		if (status == CERR_SUCCESS ){
			m_pMatchedCard->guaranteePresence (m_pTuple) ;
			break;
		}
		//delay for 1 sec and then retry
		Sleep (1000);
	}

    	TCHAR *desStr = findTupleNameStrEx (uDesiredTuple) ;
    	UINT nItems = m_pMatchedCard->getMaxParsedItems (hSocket, uDesiredTuple) ;

    	nItems =  ((UINT)rand()) % (1+nItems) ; // 0 <= result <= nItems.

    	if (nItems){ // Slight protective measure -- maybe decrease nItems.
        	switch (uDesiredTuple){
            		case CISTPL_CONFIG:
              		if ((nItems * sizeof (PARSED_CONFIG)) > MAX_PARSE_BUFFER)
                			nItems = (MAX_PARSE_BUFFER/sizeof(PARSED_CONFIG)) / 2 ;
              		break ;
            		case CISTPL_CFTABLE_ENTRY:
              		if ((nItems * sizeof (PARSED_CFTABLE)) > MAX_PARSE_BUFFER)
                			nItems = (MAX_PARSE_BUFFER/sizeof(PARSED_CFTABLE)) / 2 ;
              		break ;
            		default: // This of course never happens.
              		nItems = 0 ;
              		break ;
          }
      }

    	g_pKato->Log(LOG_DETAIL, TEXT("--> CardGetParsedTuple: Tuple type: %s, nItems: %d -- Thread%d, Sock %d Func %d"),
        						desStr, nItems, m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;

    	PVOID pBuf = (PVOID) new UCHAR [MAX_PARSE_BUFFER] ;
	switch(m_dwCaseID){
		case 104: // null pointer for nItems
			status = ::CardGetParsedTuple (hSocket, uDesiredTuple, pBuf, NULL) ;
			if(status == CERR_SUCCESS){
				g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetParsedTuple: Thread%d, Sock %d Func %d, null pointer for nItems, should NOT return CERR_SUCCESS\r\n"),
									 		m_dwThreadID, m_uLocalSock, m_uLocalFunc) ;
				status = CERR_BAD_ARGS;
			}
			else
				status = CERR_SUCCESS;
			break;
		case 105: //invalid desired tuple
			uDesiredTuple = CISTPL_END;
			status = ::CardGetParsedTuple (hSocket, uDesiredTuple, pBuf, &nItems) ;
			if(status == CERR_SUCCESS){
				g_pKato->Log(LOG_DETAIL,TEXT("--> CardGetParsedTuple: Thread%d, Sock %d Func %d, invalid desired tuple,  should NOT return CERR_SUCCESS\r\n"),
											m_dwThreadID, m_uLocalSock, m_uLocalFunc, status) ;
				status = CERR_BAD_ARGS;
			}
			else 
				status = CERR_SUCCESS;
			break;
		default:
			status = m_pMatchedCard->CardGetParsedTuple (hSocket, uDesiredTuple, pBuf, &nItems, MAX_PARSE_BUFFER) ;
			break;
	}
    	delete[] pBuf ;

    	m_lastCalled = LAST_NONE ;
	DEBUGMSG(ZONE_FUNCTION, (TEXT("- TplTest::CardGetParsedTuple()\r\n")));

}

BOOL TplTest::Test_ReadAllTuples(){
	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 %d, Func %d\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc);
             if(pOrder != NULL)
                 delete[] pOrder;
             if(pNewTplContent != NULL)
        	    delete[] pNewTplContent;
		return FALSE;
	}
	memset(pNewTplContent, 0, sizeof(TPLCONTENT)*(TOTAL_VALID_TUPLECODES+1));


	INT j = 1;
	//generate an access order
	for(INT i = 1; i<=TOTAL_VALID_TUPLECODES/2; i++){
		pOrder[i] = TOTAL_VALID_TUPLECODES -j +1;
		pOrder[TOTAL_VALID_TUPLECODES-i+1] = TOTAL_VALID_TUPLECODES - j;
		j += 2;
	}
	if(TOTAL_VALID_TUPLECODES % 2 )
		pOrder[i] = 1;

	//read tuples out
	if(ReadAllTuples(pNewTplContent, pOrder) == FALSE){
        	g_pKato->Log(LOG_DETAIL,TEXT("Thread%d, Socket %d Func %d, Read all tuples failed using alternative order\r\n"), 
        							m_dwThreadID, m_uLocalSock, m_uLocalFunc);
             delete[] pOrder;
    	        delete[] pNewTplContent;
		return FALSE;
	}

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

	CleanupTupleContents(pNewTplContent);
	delete[] pOrder;

	return TRUE;
}

#define TEST_THREAD_NUMBER	4