ma_testtool.c

gsm map协议源代码

	S16 ret;
	
	ret = maTstVerifyTknStrS(verFlg, (TknStrS*)&ptr1->xwebscnum, (TknStrS *)&ptr2->xwebscnum);
	CHEKRET;
	ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->xwbtsnum, (TknStrS *)&ptr2->xwbtsnum);
	CHEKRET;
	ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->xwlai, (TknStrS *)&ptr2->xwlai);
	RETVALUE(ROK);
}

S16 maTstVerifyExtNumg(U8 verFlg, MaXWRestrtNumg * ptr1, MaXWRestrtNumg * ptr2)
{
	U8 i=0;
	S16 ret;
	while(i < 10)
	{
		ret = maTstVerifyTknStr12(verFlg, (TknStr12 *)&ptr1->numgrp[i], (TknStr12 *)&ptr2->numgrp[i]);
		CHEKRET;
		i++;
	}
	RETVALUE(ROK);
}

PUBLIC S16 _maTstVerifyExt
(
U8      verFlg,   /* version flag */
MaXWPriExt *ptr1,    /* Pointer to the structure */
MaXWPriExt *ptr2     /* Pointer to the structure */
)
{
   S16 ret;

   TRC2(maTstVerifyExt)

   /* check if both are present or absent */
   if (ptr1->id.pres != ptr2->id.pres)
   {
      RETVALUE(RFAILED);
   }

   /* continue checking only if both the tokens are present */
   if (ptr1->id.pres == FALSE)
   {
      RETVALUE(ROK);
   }

   /* check if the value is the same */
   ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->id, (TknStrS *)&ptr2->id);
   CHEKRET;
   
   if(ptr1->etype.elmntPres.pres != ptr2->etype.elmntPres.pres)
   {
   	RETVALUE(RFAILED);
   }
   
   if(ptr1->etype.elmntPres.pres == FALSE)
   {
   	RETVALUE(ROK);
   }
   
   if(ptr1->etype.elmntPres.val != ptr2->etype.elmntPres.val)
   {
   	RETVALUE(RFAILED);
   }
   switch(ptr1->etype.elmntPres.val)
   {
   	default :
		RETVALUE(RFAILED);
	case 2:
		ret = maTstVerifyExtLocation(verFlg, (MaXWLocation *)&ptr1->etype.u.xwlocation, (MaXWLocation *)&ptr2->etype.u.xwlocation);
		CHEKRET;
		break;
	case 1:
		ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->etype.u.xwdataserv, (TknStrS *)&ptr2->etype.u.xwdataserv);
		CHEKRET;
		break;
	case 3:
		ret = maTstVerifyExtCentrex(verFlg, (MaXWCentrexInfo*)&ptr1->etype.u.xwcentrex, (MaXWCentrexInfo *)&ptr2->etype.u.xwcentrex);
		CHEKRET;
		break;
	case 4:
		ret = maTstVerifyTknU8(verFlg, (TknU8 *)&ptr1->etype.u.xwupdatetype, (TknU8 *)&ptr2->etype.u.xwupdatetype);
		CHEKRET;
		break;
	case 5:
		ret = maTstVerifyTknU8(verFlg, (TknU8 *)&ptr1->etype.u.xwauthtype, (TknU8 *)&ptr2->etype.u.xwauthtype);
		CHEKRET;
		break;	
	case 6:
		ret = maTstVerifyExtShrinkDial(verFlg, (MaXWShrinkDialNum *)ptr1->etype.u.xwshrinkdialnum, (MaXWShrinkDialNum *)ptr2->etype.u.xwshrinkdialnum);
		CHEKRET;
		break;
	case 7:
		ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->etype.u.xwcallpas, (TknStrS *)&ptr2->etype.u.xwcallpas);
		CHEKRET;
		break;
	case 8:
		ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->etype.u.xwrthotlinenum, (TknStrS *)&ptr2->etype.u.xwrthotlinenum);
		CHEKRET;
		break;
	case 9:
		ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->etype.u.xwsmartcall, (TknStrS *)&ptr2->etype.u.xwsmartcall);
		CHEKRET;
		break;
	case 10:
		ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->etype.u.xwuttype, (TknStrS *)&ptr2->etype.u.xwuttype);
		CHEKRET;
		break;
	case 11:
		ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->etype.u.xwuid, (TknStrS *)&ptr2->etype.u.xwuid);
		CHEKRET;
		break;
	case 12:
		ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->etype.u.xwhonum, (TknStrS *)&ptr2->etype.u.xwhonum);
		CHEKRET;
		break;
	case 13:
		ret = maTstVerifyTknU8(verFlg, (TknU8 *)&ptr1->etype.u.xwinsrtind, (TknU8 *)&ptr2->etype.u.xwinsrtind);
		CHEKRET;
		break;
	case 14:
		ret = maTstVerifyTknU8(verFlg, (TknU8 *)&ptr1->etype.u.xwupdtind, (TknU8 *)&ptr2->etype.u.xwupdtind);
		CHEKRET;
		break;
	case 15:
		ret = maTstVerifyTknU8(verFlg, (TknU8 *)&ptr1->etype.u.xworigtind, (TknU8 *)&ptr2->etype.u.xworigtind);
		CHEKRET;
		break;
	case 16:
		ret = maTstVerifyTknStr12(verFlg, (TknStr12 *)&ptr1->etype.u.xwcallingnum, (TknStr12 *)&ptr2->etype.u.xwcallingnum);
		CHEKRET;
		break;
	case 17:
		ret = maTstVerifyExtNumg(verFlg, (MaXWRestrtNumg *)&ptr1->etype.u.xwrestrnumg, (MaXWRestrtNumg *)&ptr2->etype.u.xwrestrnumg);
		CHEKRET;
		break;
	case 18:
		ret = maTstVerifyExtNumg(verFlg, (MaXWRestrtNumg *)&ptr1->etype.u.xwcalloutnumg, (MaXWRestrtNumg *)&ptr2->etype.u.xwcalloutnumg);
		CHEKRET;
		break;
	case 19:
		ret = maTstVerifyTknU8(verFlg, (TknU8 *)&ptr1->etype.u.xwcalloutrigt, (TknU8 *)&ptr2->etype.u.xwcalloutrigt);
		CHEKRET;
		break;
	case 20:
		ret = maTstVerifyTknStrS(verFlg, (TknStrS *)&ptr1->etype.u.xwdthotlinenum, (TknStrS *)&ptr2->etype.u.xwdthotlinenum);
		CHEKRET;
		break;

	}
   
	RETVALUE(ROK);

} /* end of maAccVerifyTknStrE */

PUBLIC S16 _maTstVerifyExtContSeq
(
U8 verFlg,
MaXWExtCont       *evt,  /* Structure */
MaXWExtCont       *evt1  /* Structure */
)
{
   S16 ret;
   U16 i;
   
   for(i=0; i < MAT_XW_MAX_NMB_PRI_EXT; i++)
   {
      ret = maTstVerifyExt(LMA_VER_ALL,&evt->priExtLst[i],
                                          &evt1->priExtLst[i]); 
      CHEKRET;
   }
   RETVALUE(ROK);
}/* maAccVerifyExtContSeq */


PRIVATE S16 maTstInitMsgCtl ( MaMsgCtl  *ctlp )
{
  TRC2(maInitMsgCtl)
   ctlp->decode = FALSE;         /* decode flag */
   ctlp->encode = FALSE;         /* encode flag */
   ctlp->skip   = FALSE;         /* skip flag */
   ctlp->swtch  = 0;             /* switch type */
   ctlp->mBuf   = NULLP;         /* msg buffer */
   ctlp->sSt    = NULLP;         /* src structure */ 
   ctlp->sTelDef= NULLP;         /* token list def in database */
   ctlp->maVer  = 0;             /* Map version */
   ctlp->errCode = 0;            /* error code */
#ifdef MA_SEG
   ctlp->level=0;
   ctlp->offLevel=0;
   ctlp->mandFlg1=FALSE;
   ctlp->mandFlg2=FALSE;
   ctlp->offIdx=0;
   cmZero((Data *)&ctlp->offset[0],(MA_MAX_SEGMENTS * sizeof(U32)));
#ifdef DEBUGP
   ctlp->offIdx1=0;
   cmZero((Data *)&ctlp->offset1[0],(MA_MAX_SEGMENTS * sizeof(U32)));
#endif /* DEBUGP */
#endif /* MA_SEG */
   RETVALUE(ROK);
} /* maInitMsgCtl */

S16 maTstSetDB(MaMsgCtl *ctlp, U8 *sSt, U8 maVer, U8 swtch, U8 type, U16 idx, Buffer *mBuf, U8 ifEnc) 
{
	/*  Buffer *mBuf;*/
	/*S16 ret; */
	/*  
	if ((ret = SGetMsg(0, 0, &mBuf )) != ROK)
	{
	RETVALUE(ret);
	}
	*/
	maTstInitMsgCtl(ctlp);
	ctlp->mBuf = mBuf;
	ctlp->sSt = sSt;  
	ctlp->maVer = maVer;
	ctlp->swtch = swtch;
	if(ifEnc)
	ctlp->encode = TRUE;
	else
	ctlp->decode = TRUE;

	/* get the appropriate database definition based on database type */

	switch(type)
	{
		case MAT_SS_REQ:
		{
			ctlp->sTelDef = maAllSSReqPDUDefs[idx].telDef;
			break;
		}
		case MAT_SS_RSP:
		{
			ctlp->sTelDef = maAllSSRspPDUDefs[idx].telDef;
			break;
		}
		case MAT_SS_RETERR:
		{
			ctlp->sTelDef = maAllSSErrPduDefs[idx];
			break;
		}
		case MAT_TST: /*extension PDU define*/
		{
			ctlp->sTelDef = maTstPduDefs[0];
			break;
		}	 	
		default:
		{
			MADBGP(MA_DBGMASK_ENCODE, (maCb.maInit.prntBuf,
			"maTstSetDB()failed, invalid database type(%d).\n", type));
			RETVALUE(RFAILED);
		}

	} /* end switch */
	RETVALUE(ROK);
}

S16 maDec_EncTest(U8 type, U8 ifEnc)
{
	MaMsgCtl ctlp;
	U8 maVer ;
	U8 swtch = 0;
	U8 * sSt;
	S16 ret=0;
	U32 dbgMsk;

	MaAllSSEv *encEvt=NULLP;
	MaAllSSEv *decEvt=NULLP;
	Size  size=0;
	U16 len=0;
	Buffer    *mBuf2;	 /* message buffer */
	Buffer    *mBuf;
		
	size = sizeof(MaAllSSEv); 
	printf("sizeof(MaAllSSEv): %d\r\n", sizeof(MaAllSSEv)); /*645964 BYTE (2)*/
	printf("sizeof(MaExtContSeq):%d\r\n", sizeof(MaExtContSeq));/*288 byte (2)*/
	printf("sizeof(MaXWExtContSeq)%d\r\n", sizeof(MaXWExtContSeq)); /*116 byte*/
	printf("sizeof(MaXWPriExt):%d\r\n", sizeof(MaXWPriExt));
	printf("sizeof(MaPriExtLst):%d\r\n", sizeof(MaPriExtLst));
	printf("sizeof(MaXWPriExtLst):%d\r\n", sizeof(MaXWPriExtLst));
	printf("sizeof(TknStrE):%d\r\n", sizeof(TknStrE));
	printf("sizeof(MaExtType)%d\r\n", sizeof(MaExtType)); /*116 byte*/

/*
	dbgMsk = (0xFFFFFFFF); 
	maCb.maInit.dbgMask = dbgMsk;
*/	
/*	if(encEvt == NULLP)
	{
		if (SAlloc(maCb.maInit.region, &size, 0, (Data**) &encEvt) != ROK)
		{
			DBGTST("maTstMsgEncDec: SAlloc encEvt failed \n");
			encEvt = NULLP;
			RETVALUE(RFAILED);
		}
	}
	*/
	encEvt = maGlobEncEv;
/*	if(decEvt == NULLP)
	{
		if (SAlloc(maCb.maInit.region, &size, 0, (Data**) &decEvt) != ROK)
		{
			DBGTST("maTstMsgEncDec: SAlloc decEvtfailed \n");
			encEvt = NULLP;
			decEvt = NULLP;
			SFree(maCb.maInit.region, (Data *) encEvt, size);
			RETVALUE(RFAILED);
		}
	}
*/
	decEvt = maGlobDecEv;
/* allocate a message buffer for encoding operation parameters */
	if ((ret = SGetMsg(maCb.maInit.region, maCb.maInit.pool, &mBuf)) != ROK)
	{
		DBGTST("maTstMsgEncDec: SGetMsg failed \n");
		encEvt = NULLP;
		decEvt = NULLP;
		SFree(maCb.maInit.region, (Data *) encEvt, size);
		SFree(maCb.maInit.region, (Data *) decEvt, size);
		RETVALUE(ret);
	}

	if ((ret = SGetMsg(maCb.maInit.region, maCb.maInit.pool, &mBuf2)) != ROK)
	{
		DBGTST("maTstMsgEncDec: SGetMsg failed \n");
		encEvt = NULLP;
		decEvt = NULLP;
		SFree(maCb.maInit.region, (Data *) encEvt, size);
		SFree(maCb.maInit.region, (Data *) decEvt, size);
		SPutMsg(mBuf);
		RETVALUE(ret);
	}

	cmMemset((U8 *)encEvt, 0, size);
	cmMemset((U8 *)decEvt, 0, size);

	/* get the message definiation for appropiate cause */

	switch(type)
	{
		default :
			DBGTST("please input correct test type!\r\n");
			RETVALUE(RFAILED);
		case 0 : /*test extension parameters encode&decode*/
			if(ifEnc)
			{
				MaXWExtContSeq *encextEv, *decextEv;

				DBGTST("\r\n\r\n**************************\r\n****start encode excontain test , then decode the buff****\r\n\r\n");
			
				encextEv = (MaXWExtContSeq *)encEvt;
				ret = maTstSetCon(encextEv);
				if(ret != ROK)
				{
					printf("set extcon error!\r\n");
					RETVALUE(RFAILED);
				}

				sSt = (U8 *)encextEv;
				ret = maTstSetDB(&ctlp, sSt, LMA_VER_ALL, swtch , MAT_TST, MA_MI_UPLOC_REQ, mBuf, 1);
				if(ret != ROK)
				{
					printf("set DB error!\r\n");
					RETVALUE(RFAILED);
				}
				
				DBGTST("\r\n\r\n*****start encode the buffer*****\r\n\r\n");
				ret = maEncStart(&ctlp);
				if(ret != ROK)
				{
					DBGTST("enc failed!\r\n");
					RETVALUE(RFAILED);
				}
				
				SPrntMsg(ctlp.mBuf, 0, 0);

				DBGTST("\r\n\r\n*****start decode the buffer*****\r\n\r\n");
				{
					decextEv = (MaXWExtContSeq *)decEvt;
					sSt = (U8 *)decextEv;
					maTstSetDB(&ctlp, sSt, LMA_VER_ALL, swtch , MAT_TST, MA_MI_UPLOC_REQ, mBuf, 0);
					ret = maDecStart(&ctlp);
					if(ret != ROK)
					{
						DBGTST("decode failed!\r\n");
						RETVALUE(RFAILED);
					}
				}


				DBGTST("\r\n\r\n*****start verify the enc and dec buffer*****\r\n\r\n");
				ret = maTstVerifyExtContSeq(0, encextEv, decextEv);
				if(ret != ROK)
				{
					DBGTST("verify enc evnt -- dec event failed!\r\n");
					RETVALUE(RFAILED);
				}
				else if (ret == ROK)
				{
					DBGTST("verify enc evnt -- dec event success!\r\n\r\n*********test success!*************\r\n\r\n\r\n");
				}

				ret = SPutMsg(mBuf);
				CHEKRET;
				ret = SPutMsg(mBuf2);
				CHEKRET;
			}
			break;	
	}
	RETVALUE(ROK);
   
}

S16 maTstEncDec(void)
{
	static U8 loop = 0;
	S16 ret;

	printf("start loop %d test\r\n\r\n", loop);
	
	ret = maDec_EncTest(0,1);
	if(ret != ROK)
	{
		printf("the loop %d test failed , quit!\r\n\r\n", loop);
		exit(1);
	}
	
	printf("the loop %d test success!\r\n\r\n", loop);

	loop++;
	if(loop == 4)
	{
		printf("all test loop over!\r\n");
		exit(0);
	}
	RETVALUE(ROK);
	
}

#endif/*XWEXT*/