EMS/svc.ems
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
f6d74c5b9b5c0978ef671d069d34e142c64ebad0
svc.ems/plat/mgc_v2/ut/mgc_v2_test.c
simonzhangsz 9930e4e58f init ems server code
2024-09-27 15:39:34 +08:00

1787 lines
48 KiB
C
Raw Blame History

#include "./include/CUnit.h"
#include "./include/CUError.h"
#include "./include/Automated.h"
#define MGC_TEST_ENABLE
#include "../../public/src/include/includes.h"
#include "../../public/src/include/public.h"
#include "../src/include/mgc_struct.h"
#include "../src/include/mgc_8ecp.h"
#include "../src/include/mgc_chnl_info.h"
#include "../src/include/mgc_conn_info.h"
#include "../src/include/mgc_ctl.h"
#include "../src/include/mgc_internal.h"
#include "../src/include/mgc_mgcp.h"
#include "../src/include/mgc_mg_info.h"
#include "../src/include/mgc_port_info.h"
#include "../src/include/mgc_phy_port.h"
#include "../src/include/mgc.h"
#include "../src/include/mgc_debug.h"
#include "../src/include/mgc_tandem_info.h"
#include "../src/include/mgc_sur_info.h"
#include "../../mgcp/src/include/mgcp.h"
#include "../src/mgc.c"
#include "../src/mgc_8ecp.c"
#include "../src/mgc_chnl_info.c"
#include "../src/mgc_conn_info.c"
#include "../src/mgc_ctl.c"
#include "../src/mgc_internal.c"
#include "../src/mgc_mgcp.c"
#include "../src/mgc_mg_info.c"
#include "../src/mgc_phy_port.c"
#include "../src/mgc_port_info.c"
#include "../src/mgc_tandem_info.c"
#include "../src/mgc_sur_info.c"
#include "../src/mgc_debug.c"
#include "../../rtp/src/include/rtp.h"
extern void mgcp_init(void);
extern void mgcp_timer(void);
extern void debug_init();
extern int iptrMainInit();
extern void snmp_init(WORD nport);
#define MGC_TEST_SAP_NUM 10
#define MGC_TEST_MG_NUM 1025
typedef enum
{
OPERA_STATE_UNDEF =-1,
OPERA_STATE_SEND,
OPERA_STATE_GET,
}OPERA_STATE;
typedef struct _opera_struct
{
int userPort;
OPERA_STATE status;
MGC_OPER_RESULT result;
}opera_struct;
typedef struct _test_mgc_sap
{
int id;
MGC_SAP mgcSap;
int sapIndex;
}test_mgc_sap;
typedef struct _test_mg
{
int mgNo;
int userPort;
int PortType;
int portNo;
BOOL enable;
MG_ATTR mgAttr;
test_mgc_sap *pMgcsap;
}test_mg;
typedef struct _MGC_RTP_SAP
{
RTP_SAP rtpSap;
int rtpSapIndex;
int hdlport;
int userPort;
WORD localport;
char localIP[33];
}MGC_RTP_SAP;
test_mg mgA , mgB , mgRtpProxy , mgAas;
test_mgc_sap testSap[MGC_TEST_SAP_NUM];
opera_struct testOpera;
MGC_RTP_SAP mgcRtpSap;
int mgc_rtp_handshake(WORD usrPort, WORD hdlPort, WORD rtpPort)
{
return 1;
}
int mgc_rtp_recv(WORD usrPort, WORD hdlPort, BYTE pt, WORD sn, BYTE *payload, WORD len)
{
fputs(payload, stdout);
memset(payload , 0 , len);
return 0;
}
BOOL mgc_test_rtp_bind(MGC_RTP_SAP *pRtpSap)
{
RTP_SAP *pSap;
if(pRtpSap == NULL)
return FALSE;
pSap = &(pRtpSap->rtpSap);
sprintf(pSap->name , "MGC_RTP_SAP");
pSap->rtp_handshake = mgc_rtp_handshake;
pSap->rtp_recv = mgc_rtp_recv;
pRtpSap->rtpSapIndex = rtp_bind(pSap);
if(pRtpSap->rtpSapIndex < 0)
return FALSE;
return TRUE;
}
opera_struct *mgc_find_owner(WORD usrPort , WORD mgcPort)
{
opera_struct *pOpera;
pOpera = &testOpera;
if(pOpera->userPort == usrPort)
return pOpera ;
return NULL;
}
int mgc_ind_test(CHNL chnl, MGC_CMD_TYPE cmd, WORD *usrPort, WORD mgcPort, MEDIA_ATTR *pMediaAttr)
{
PUB_SDP_MSG *pSdp;
MGC_DEBUG("mg[%d]port[%d]chnl[%d]conn[%d] get ind %s from mgcPort[%d]",
chnl.mgNo , chnl.portNo , chnl.chlNo , chnl.connectNo , mgc_port_info_print_cmd(cmd) , mgcPort);
switch(cmd)
{
case MGC_CMD_AUEP:
*usrPort = mgcPort;
mgc_rsp(cmd, *usrPort, mgcPort, 200 , NULL);
break;
case MGC_CMD_CRCX:
*usrPort = mgcPort;
if(pMediaAttr != NULL)
{
pSdp = &pMediaAttr->sdp;
MGC_DEBUG("remote ip : %s:%d" , pSdp->c.addr , pSdp->medias.medias[0].m.port);
}
mgc_rsp(cmd, *usrPort, mgcPort, 200 , NULL);
break;
case MGC_CMD_DLCX:
*usrPort = mgcPort;
mgc_rsp(cmd, *usrPort, mgcPort, 250 , NULL);
break;
default:
break;
}
return 0;
}
int mgc_cnf_test(WORD usrPort, WORD mgcPort, MGC_MG_OPER_ID_TYPE operId, MGC_OPER_RESULT success, WORD cause)
{
opera_struct *pOpera = NULL;
pOpera = mgc_find_owner(usrPort, mgcPort);
if(pOpera)
{
if(pOpera->status== OPERA_STATE_SEND)
{
pOpera->status= OPERA_STATE_GET;
pOpera->result = success;
MGC_DEBUG("opera[%d] get response %s" , pOpera->userPort , success?"success":"failure");
}
else
{
pOpera->result = MGC_OPER_FAILURE;
MGC_WARN("opera[%d] error state" , pOpera->userPort);
CU_ASSERT_EQUAL_FATAL(pOpera->status , OPERA_STATE_SEND);
}
}
else
{
MGC_WARN("usrPort :%d mgcPort :%d , lost owner" , usrPort , mgcPort);
}
return 0;
}
void test_mgc_wait_time(opera_struct *pOpera , int seconds)
{
struct timeval t1 ,t2 , t3;
if(pOpera == NULL)
return;
MGC_DEBUG(" wait %d seconds....." , seconds);
gettimeofday(&t2 , NULL);
gettimeofday(&t3 , NULL);
while(1)
{
gettimeofday(&t1 , NULL);
if(t1.tv_usec - t2.tv_usec > 10)
{
iptrans_timer();
mgcp_timer();
debug_rt();
rtp_timer();
mgc_timer();
gettimeofday(&t2 , NULL);
}
if(t1.tv_sec - t3.tv_sec > seconds)
pOpera->status = OPERA_STATE_UNDEF;
if(pOpera->status!= OPERA_STATE_SEND)
return;
}
return;
}
void mgc_test_sap_init(test_mgc_sap *pSap , int id)
{
if(pSap == NULL)
return;
pSap->id = id;
sprintf(pSap->mgcSap.usrName , "test_mgcsap[%d]" , id);
pSap->mgcSap.usrType = MGC_USER_TYPE_MGC;
pSap->mgcSap.cnf_func = mgc_cnf_test;
pSap->mgcSap.ind_func = NULL;
return;
}
void mgc_test_mg_init(test_mg *pMg , char *name , char *mgAddr , int mgType , int PortType)
{
if((pMg == NULL) ||(name == NULL)||(mgAddr == NULL))
return;
pMg->enable = FALSE;
pMg->mgNo = -1;
pMg->userPort = -1;
pMg->PortType = PortType;
pMg->pMgcsap = NULL;
pMg->mgAttr.mgType = mgType;
sprintf(pMg->mgAttr.domain, "%s" , name);
pMg->mgAttr.codecList.num = 6;
pMg->mgAttr.codecList.priority = 0;
pMg->mgAttr.codecList.codec[0] = MGC_VCTYPE_PCMA;
pMg->mgAttr.codecList.codec[1] = MGC_VCTYPE_PCMU;
pMg->mgAttr.codecList.codec[2] = MGC_VCTYPE_GSM;
pMg->mgAttr.codecList.codec[3] = MGC_VCTYPE_GSM_EFR;
pMg->mgAttr.codecList.codec[4] = MGC_VCTYPE_AMR_12_2;
pMg->mgAttr.codecList.codec[5] = MGC_VCTYPE_G729B;
pMg->mgAttr.ctrlType = MGC_MG_CTRL_TYPE_MGCP;
if(pMg->mgAttr.mgType == MGC_MG_TYPE_TANDEM)
{
pMg->mgAttr.epDes = MGCP_EP_NAME_UNSTRUCTURED;
}
else
{
pMg->mgAttr.epDes = MGCP_EP_NAME_STRUCTURED;
}
pMg->mgAttr.toneCap = 1;
pMg->mgAttr.ip = inet_addr(mgAddr);
pMg->mgAttr.maxChnls = 512;
pMg->mgAttr.ptime = 4*20;// 80ms
pMg->mgAttr.maxPorts = 30;
pMg->mgAttr.auditTimer = 15*10;
pMg->portNo = 0;
return;
}
int mgc_cunit_clean(void)
{
return 0;
}
BOOL mgc_get_local_ip(char *ipAddr)
{
struct hostent *host;
char localName[50];
if(ipAddr == NULL)
return FALSE;
if (gethostname(localName , 50) == -1)
{
return FALSE;
}
if ((host = gethostbyname(localName)) == NULL)
{
return FALSE;
}
sprintf(ipAddr, "%d.%d.%d.%d",
(BYTE)host->h_addr_list[0][0],
(BYTE)host->h_addr_list[0][1],
(BYTE)host->h_addr_list[0][2],
(BYTE)host->h_addr_list[0][3]);
return TRUE;
}
int mgc_test_cunit_init(void)
{
test_mgc_sap *pSap;
char ipAddr[33];
int i;
debug_init();
iptrMainInit();
mgcp_init();
rtp_init();
snmp_init(4957);
mgc_get_local_ip(ipAddr);
mgc_test_mg_init(&mgA , "mg-4444" , "172.54.240.202" , MGC_MG_TYPE_AudioCoder , MGC_PHY_PORT_TYPE_E1 );
mgc_test_mg_init(&mgB , "mg-5555" , "172.54.240.214" , MGC_MG_TYPE_AudioCoder , MGC_PHY_PORT_TYPE_E1 );
mgc_test_mg_init(&mgRtpProxy, "rtpproxy-1234" , "172.54.240.201" , MGC_MG_TYPE_TANDEM, MGC_PHY_VIRTUAL_TYPE_TANDEM);
mgc_test_mg_init(&mgAas , "aas", ipAddr , MGC_MG_TYPE_ANN , MGC_PHY_VIRTUAL_TYPE_ANN);
for(i=0 ; i<MGC_TEST_SAP_NUM ; i++)
{
pSap = &testSap[i];
mgc_test_sap_init(pSap, i);
}
return 0;
}
void test_mgc_init(void)
{
char localIp[35];
MGC_DEBUG("enter %s", __FUNCTION__);
mgc_get_local_ip(localIp);
mgc_init(1234, inet_addr(localIp), inet_addr("172.54.240.178"));
return;
}
void test_mgc_sap_bind_and_unbind(void)
{
int i , num ,ret;
test_mgc_sap *pSap;
num = 0;
for(i=0 ; i<MGC_TEST_SAP_NUM ; i++)
{
pSap = &testSap[i];
pSap->sapIndex = mgc_bind(&pSap->mgcSap);
if(pSap->sapIndex >= 0)
num++;
}
MGC_DEBUG("testSap bind success %d" , num);
CU_ASSERT_EQUAL_FATAL(num , MGC_MAX_NUM_OF_SAP-1);
for(i=0 ; i<MGC_TEST_SAP_NUM ; i++)
{
pSap = &testSap[i];
ret = mgc_unbind(&pSap->mgcSap , pSap->sapIndex);
if(i < num)
{
CU_ASSERT_FATAL(ret>=0);
}
else
{
CU_ASSERT_FATAL(ret < 0);
}
mgc_test_sap_init(pSap, pSap->id);
}
return;
}
void test_mgc_mg_create_and_delete(void)
{
int i , num ,ret , k ;
test_mgc_sap *pSap;
test_mg mgTest[MGC_TEST_MG_NUM];
test_mg *pMg = NULL;
char buf[32];
pSap = &testSap[0];
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret>=0);
pSap->sapIndex = ret;
num = 0;
k = mgc_mg_info_created_num();
for(i=0 ; i<MGC_TEST_MG_NUM ; i++)
{
pMg = &mgTest[i];
sprintf(buf , "testmg[%d]" , i);
mgc_test_mg_init(pMg, buf , "192.168.1.20" , MGC_MG_TYPE_AudioCoder , MGC_PHY_PORT_TYPE_E1);
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
if(ret>=0)
num++;
pMg->mgNo = ret;
}
CU_ASSERT_EQUAL_FATAL(num , (mgc_mg_info_created_num()-k));
CU_ASSERT_EQUAL_FATAL(mgc_mg_info_created_num() , mgc_ctl_mg_num());
for(i=0 ; i<MGC_TEST_MG_NUM ; i++)
{
pMg = &mgTest[i];
ret = mgc_delete_MG(pMg->pMgcsap->sapIndex , pMg->mgNo);
if(i < num)
{
CU_ASSERT_FATAL(ret>=0);
}
else
{
CU_ASSERT_FATAL(ret<0);
}
}
CU_ASSERT_EQUAL_FATAL(mgc_mg_info_created_num() , mgc_ctl_mg_num());
CU_ASSERT_EQUAL_FATAL(k , mgc_ctl_mg_num());
mgc_unbind(&pSap->mgcSap , pSap->sapIndex);
return;
}
void test_mgc_mg_max_num_ctl(void)
{
int i , num ,ret , k , maxNum;
test_mgc_sap *pSap;
test_mg mgTest[MGC_TEST_MG_NUM];
test_mg *pMg = NULL;
char buf[32];
pSap = &testSap[0];
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret>=0);
pSap->sapIndex = ret;
maxNum = MGC_TEST_MG_NUM/2;
mgc_ctl_set_mg_max_num(maxNum);
num = 0;
k = mgc_mg_info_created_num();
for(i=0 ; i<MGC_TEST_MG_NUM ; i++)
{
pMg = &mgTest[i];
sprintf(buf , "testmg[%d]" , i);
mgc_test_mg_init(pMg, buf , "192.168.1.20" , MGC_MG_TYPE_AudioCoder , MGC_PHY_PORT_TYPE_E1);
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
if(ret>=0)
num++;
pMg->mgNo = ret;
}
CU_ASSERT_EQUAL_FATAL(num , maxNum);
CU_ASSERT_EQUAL_FATAL(num , (mgc_mg_info_created_num()-k));
CU_ASSERT_EQUAL_FATAL(mgc_mg_info_created_num() , mgc_ctl_mg_num());
for(i=0 ; i<MGC_TEST_MG_NUM ; i++)
{
pMg = &mgTest[i];
ret = mgc_delete_MG(pMg->pMgcsap->sapIndex , pMg->mgNo);
if(i < num)
{
CU_ASSERT_FATAL(ret>=0);
}
else
{
CU_ASSERT_FATAL(ret<0);
}
}
CU_ASSERT_EQUAL_FATAL(mgc_mg_info_created_num() , mgc_ctl_mg_num());
CU_ASSERT_EQUAL_FATAL(k , mgc_ctl_mg_num());
mgc_ctl_set_mg_max_num(MGC_MAX_NUM_OF_MG);
mgc_unbind(&pSap->mgcSap , pSap->sapIndex);
return;
}
void test_mgc_mg_create_twice(void)
{
int num ,ret , k ;
test_mgc_sap *pSap;
test_mg *pMg = NULL;
pMg = &mgA;
pSap = &testSap[0];
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret>=0);
pSap->sapIndex = ret;
num = mgc_mg_info_created_num();
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
CU_ASSERT(ret >= 0);
pMg->mgNo = ret;
k = mgc_mg_info_created_num();
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
CU_ASSERT(ret >= 0);
CU_ASSERT_EQUAL_FATAL(ret , pMg->mgNo);
CU_ASSERT_EQUAL_FATAL(k , mgc_mg_info_created_num());
CU_ASSERT_EQUAL_FATAL(k , mgc_ctl_mg_num());
ret = mgc_delete_MG(pMg->pMgcsap->sapIndex , pMg->mgNo);
CU_ASSERT(ret >= 0);
ret = mgc_delete_MG(pMg->pMgcsap->sapIndex , pMg->mgNo);
CU_ASSERT(ret < 0);
CU_ASSERT_EQUAL_FATAL(num , mgc_mg_info_created_num());
mgc_unbind(&pSap->mgcSap , pSap->sapIndex);
return;
}
void test_mgc_port_add_and_delete(void)
{
int i , num ,ret , k ;
test_mgc_sap *pSap;
test_mg *pMg = NULL;
PHY_PORT_INFO phyPort;
pMg = &mgA;
pSap = &testSap[0];
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret>=0);
pSap->sapIndex = ret;
num = mgc_chnl_info_assigned_num();
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
CU_ASSERT(ret >= 0);
pMg->mgNo = ret;
k = 0;
for(i=0 ; i<MGC_MAX_PHY_PORT_PER_MG ; i++)
{
ret = mgc_add_port(pMg->pMgcsap->sapIndex ,pMg->mgNo, i , pMg->PortType);
if(ret >= 0)
{
mgc_phy_port_set_chnl_num(&phyPort, pMg->PortType);
k += phyPort.chnlNum;
}
}
CU_ASSERT_EQUAL_FATAL(k , mgc_ctl_chnl_num()-num);
CU_ASSERT_EQUAL_FATAL(mgc_ctl_chnl_num() , mgc_chnl_info_assigned_num());
for(i=0 ; i<MGC_MAX_PHY_PORT_PER_MG ; i++)
{
ret = mgc_delete_port(pMg->pMgcsap->sapIndex ,pMg->mgNo, i);
}
CU_ASSERT_EQUAL_FATAL(num , mgc_chnl_info_assigned_num());
CU_ASSERT_EQUAL_FATAL(mgc_ctl_chnl_num() , mgc_chnl_info_assigned_num());
mgc_unbind(&pSap->mgcSap , pSap->sapIndex);
return;
}
void test_mgc_create_mg_a(void)
{
int ret;
opera_struct opera;
test_mgc_sap *pSap;
test_mg *pMg = NULL;
MG_INFO *pMgInfo;
pSap = &testSap[0];
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret>=0);
pSap->sapIndex = ret;
MGC_DEBUG("enter %s", __FUNCTION__);
pMg = &mgA;
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
CU_ASSERT(ret >= 0);
pMg->mgNo = ret;
pMg->portNo = 0;
ret = mgc_add_port(pMg->pMgcsap->sapIndex ,pMg->mgNo , pMg->portNo , pMg->PortType);
CU_ASSERT(ret >= 0);
opera.status = OPERA_STATE_SEND;
test_mgc_wait_time(&opera , 2);
pMgInfo = mgc_mg_info_get_index_mg(pMg->mgNo);
CU_ASSERT_PTR_NOT_NULL_FATAL(pMgInfo);
if(pMgInfo->enable == FALSE)
{
MGC_ERROR("mg[%d] %s is not detected" , pMg->mgNo, pMg->mgAttr.domain);
}
CU_ASSERT_TRUE_FATAL(pMgInfo->enable);
MGC_DEBUG("mg[%d] %s , bind mgcSap[%d] , attach phyport[%d]" , pMg->mgNo, pMg->mgAttr.domain ,
pMg->pMgcsap->sapIndex , ret);
return;
}
void test_mgc_create_mg_b(void)
{
int ret;
opera_struct opera;
test_mgc_sap *pSap;
test_mg *pMg = NULL;
MG_INFO *pMgInfo;
pSap = &testSap[0];
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret>=0);
pSap->sapIndex = ret;
MGC_DEBUG("enter %s", __FUNCTION__);
pMg = &mgB;
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
CU_ASSERT(ret >= 0);
pMg->mgNo = ret;
pMg->portNo = 0;
ret = mgc_add_port(pMg->pMgcsap->sapIndex ,pMg->mgNo , pMg->portNo , pMg->PortType);
CU_ASSERT(ret >= 0);
opera.status = OPERA_STATE_SEND;
test_mgc_wait_time(&opera , 2);
pMgInfo = mgc_mg_info_get_index_mg(pMg->mgNo);
CU_ASSERT_PTR_NOT_NULL_FATAL(pMgInfo);
if(pMgInfo->enable == FALSE)
{
MGC_ERROR("mg[%d] %s is not detected" , pMg->mgNo, pMg->mgAttr.domain);
}
CU_ASSERT_TRUE_FATAL(pMgInfo->enable);
MGC_DEBUG("mg[%d] %s , bind mgcSap[%d] , attach phyport[%d]" , pMg->mgNo, pMg->mgAttr.domain ,
pMg->pMgcsap->sapIndex , ret);
return;
}
void test_mgc_create_tandem(void)
{
int ret;
opera_struct opera;
test_mgc_sap *pSap;
test_mg *pMg = NULL;
MG_INFO *pMgInfo;
MGC_DEBUG("enter %s", __FUNCTION__);
pSap = &testSap[0];
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret>=0);
pSap->sapIndex = ret;
pMg = &mgRtpProxy;
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
CU_ASSERT(ret >= 0);
pMg->mgNo = ret;
opera.status = OPERA_STATE_SEND;
test_mgc_wait_time(&opera , 2);
pMgInfo = mgc_mg_info_get_index_mg(pMg->mgNo);
CU_ASSERT_PTR_NOT_NULL_FATAL(pMgInfo);
if(pMgInfo->enable == FALSE)
{
MGC_ERROR("mg[%d] %s is not detected" , pMg->mgNo, pMg->mgAttr.domain);
}
CU_ASSERT_TRUE_FATAL(pMgInfo->enable);
MGC_DEBUG("mg[%d] %s , bind mgcSap[%d] , attach phyport[%d]" , pMg->mgNo, pMg->mgAttr.domain ,
pMg->pMgcsap->sapIndex , ret);
return;
}
void test_mgc_create_aas_mg_and_mgc(void)
{
int ret;
opera_struct opera;
test_mgc_sap *pSap;
test_mg *pMg = NULL;
MG_INFO *pMgInfo;
MGC_DEBUG("enter %s", __FUNCTION__);
pMg = &mgAas;
pSap = &testSap[1];
pSap->mgcSap.usrType = MGC_USER_TYPE_MGC;
MGC_DEBUG("create mgc aas");
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret > 0);
pSap->sapIndex = ret;
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
CU_ASSERT(ret >= 0);
pMg->mgNo = ret;
pMgInfo = mgc_mg_info_get_index_mg(pMg->mgNo);
opera.status = OPERA_STATE_SEND;
test_mgc_wait_time(&opera , 2);
CU_ASSERT(pMgInfo->enable);
MGC_DEBUG("create mg aas");
pSap = &testSap[2];
pSap->mgcSap.usrType = MGC_USER_TYPE_MG;
pSap->mgcSap.ind_func = mgc_ind_test;
pSap->mgcSap.cnf_func = NULL;
ret = mgc_bind(&pSap->mgcSap);
CU_ASSERT(ret > 0);
pSap->sapIndex = ret;
pMg->pMgcsap = pSap;
ret = mgc_create_MG(pMg->pMgcsap->sapIndex , &pMg->mgAttr);
CU_ASSERT(ret >= 0);
pMg->mgNo = ret;
opera.status = OPERA_STATE_SEND;
test_mgc_wait_time(&opera , 2);
pMgInfo = mgc_mg_info_get_index_mg(pMg->mgNo);
CU_ASSERT(pMgInfo->enable);
pMgInfo = mgc_mg_info_get_index_mg(pMg->mgNo);
CU_ASSERT_PTR_NOT_NULL_FATAL(pMgInfo);
if(pMgInfo->enable == FALSE)
{
MGC_ERROR("mg[%d] %s is not detected" , pMg->mgNo, pMg->mgAttr.domain);
}
CU_ASSERT_TRUE_FATAL(pMgInfo->enable);
return;
}
void test_mgc_crcx_and_dlcx(void)
{
int ret , num;
MG_INFO *pMgInfo;
test_mg *pMg = &mgA;
CHNL chnl;
opera_struct *pOpera = &testOpera;
MGC_DEBUG("test crcx and dlcx");
pMgInfo = mgc_mg_info_get_index_mg(pMg->mgNo);
CU_ASSERT_PTR_NOT_NULL_FATAL(pMgInfo);
CU_ASSERT_TRUE_FATAL(pMgInfo->enable);
chnl.mgNo = pMg->mgNo;
chnl.portNo = pMg->portNo;
chnl.chlNo = 1;
chnl.connectNo = 0 ;
MGC_DEBUG("enter %s", __FUNCTION__);
num = mgc_connect_inused_num();
pOpera->userPort++;
ret = mgc_crcx_chnl(pOpera->userPort , chnl);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 10);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
//MGC_DEBUG("before num %d , after num %d " , num , mgc_connect_inused_num());
CU_ASSERT_EQUAL_FATAL(num , mgc_connect_inused_num());
return;
}
void test_mgc_connect(void)
{
int ret , num;
opera_struct *pOpera = &testOpera;
test_mg *pMgA = &mgA;
CHNL chnl_a;
test_mg *pMgB = &mgB;
CHNL chnl_b;
MGC_DEBUG("enter %s", __FUNCTION__);
chnl_a.mgNo = pMgA->mgNo;
chnl_a.portNo = pMgA->portNo;
chnl_a.chlNo = 1;
chnl_a.connectNo = 0 ;
chnl_b.mgNo = pMgB->mgNo;
chnl_b.portNo = pMgB->portNo;
chnl_b.chlNo = 1;
chnl_b.connectNo = 0 ;
num = mgc_connect_inused_num();
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 60);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
CU_ASSERT_EQUAL_FATAL(num , mgc_connect_inused_num());
return;
}
void test_mgc_connect_tone(void)
{
int ret ;
opera_struct *pOpera = &testOpera;
test_mg *pMgA = &mgA;
CHNL chnl_a;
test_mg *pMgB = &mgB;
CHNL chnl_b;
chnl_a.mgNo = pMgA->mgNo;
chnl_a.portNo = pMgA->portNo;
chnl_a.chlNo = 1;
chnl_a.connectNo = 0 ;
chnl_b.mgNo = pMgB->mgNo;
chnl_b.portNo = pMgB->portNo;
chnl_b.chlNo = 1;
chnl_b.connectNo = 0 ;
MGC_DEBUG("enter %s", __FUNCTION__);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 3);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 3);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 10);
pOpera->userPort++;
ret = mgc_connect_tone(pOpera->userPort , chnl_b , chnl_a , 8 , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 3);
// CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
// CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
/*
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 5);
*/
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 10);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 10);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
return;
}
void test_mgc_connect_aas(void)
{
int ret ;
opera_struct *pOpera = &testOpera;
test_mg *pMgA = &mgA;
CHNL chnl_a;
test_mg *pMgB = &mgB;
CHNL chnl_b;
chnl_a.mgNo = pMgA->mgNo;
chnl_a.portNo = pMgA->portNo;
chnl_a.chlNo = 1;
chnl_a.connectNo = 0 ;
chnl_b.mgNo = pMgB->mgNo;
chnl_b.portNo = pMgB->portNo;
chnl_b.chlNo = 1;
chnl_b.connectNo = 0 ;
pOpera->userPort++;
MGC_DEBUG("enter %s", __FUNCTION__);
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 10);
MGC_DEBUG("connect chnl_a to aas");
pOpera->userPort++;
ret = mgc_connect_AAS(pOpera->userPort , chnl_b , chnl_a , 8 , 1 ,3);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 60);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 10);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 10);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
return;
}
void test_mgc_connect_tandem_to_connection(void)
{
int ret , tandemId;
opera_struct *pOpera = &testOpera;
test_mg *pMgA = &mgA;
CHNL chnl_a;
test_mg *pMgB = &mgB;
CHNL chnl_b;
MGC_DEBUG("enter %s", __FUNCTION__);
chnl_a.mgNo = pMgA->mgNo;
chnl_a.portNo = pMgA->portNo;
chnl_a.chlNo = 1;
chnl_a.connectNo = 0 ;
chnl_b.mgNo = pMgB->mgNo;
chnl_b.portNo = pMgB->portNo;
chnl_b.chlNo = 1;
chnl_b.connectNo = 0 ;
tandemId = mgc_get_idle_tandem_id();
pOpera->userPort++;
ret = mgc_bind_chnl_to_tandem(pOpera->userPort , chnl_a ,tandemId);
CU_ASSERT(ret >= 0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 15);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_delete_tandem(pOpera->userPort , tandemId);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
return;
}
void test_mgc_connect_connection_to_tandem(void)
{
int ret , tandemId;
opera_struct *pOpera = &testOpera;
test_mg *pMgA = &mgA;
CHNL chnl_a;
test_mg *pMgB = &mgB;
CHNL chnl_b;
MGC_DEBUG("enter %s", __FUNCTION__);
chnl_a.mgNo = pMgA->mgNo;
chnl_a.portNo = pMgA->portNo;
chnl_a.chlNo = 1;
chnl_a.connectNo = 0 ;
chnl_b.mgNo = pMgB->mgNo;
chnl_b.portNo = pMgB->portNo;
chnl_b.chlNo = 1;
chnl_b.connectNo = 0 ;
tandemId = mgc_get_idle_tandem_id();
pOpera->userPort++;
ret = mgc_bind_chnl_to_tandem(pOpera->userPort , chnl_b ,tandemId);
CU_ASSERT(ret >= 0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 15);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_delete_tandem(pOpera->userPort , tandemId);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
return;
}
void test_mgc_connect_tandem_to_tandem(void)
{
int ret , tandemId_a , tandemId_b;
opera_struct *pOpera = &testOpera;
test_mg *pMgA = &mgA;
CHNL chnl_a;
test_mg *pMgB = &mgB;
CHNL chnl_b;
chnl_a.mgNo = pMgA->mgNo;
chnl_a.portNo = pMgA->portNo;
chnl_a.chlNo = 1;
chnl_a.connectNo = 0 ;
chnl_b.mgNo = pMgB->mgNo;
chnl_b.portNo = pMgB->portNo;
chnl_b.chlNo = 1;
chnl_b.connectNo = 0 ;
MGC_DEBUG("enter %s", __FUNCTION__);
tandemId_a = mgc_get_idle_tandem_id();
pOpera->userPort++;
ret = mgc_bind_chnl_to_tandem(pOpera->userPort , chnl_a ,tandemId_a);
CU_ASSERT(ret >= 0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
tandemId_b = mgc_get_idle_tandem_id();
pOpera->userPort++;
ret = mgc_bind_chnl_to_tandem(pOpera->userPort , chnl_b ,tandemId_b);
CU_ASSERT(ret >= 0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 15);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_delete_tandem(pOpera->userPort , tandemId_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_delete_tandem(pOpera->userPort , tandemId_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
return;
}
void test_mgc_connect_tandem_to_aas(void)
{
int ret ,tandemId;
opera_struct *pOpera = &testOpera;
test_mg *pMgA = &mgA;
CHNL chnl_a;
test_mg *pMgB = &mgB;
CHNL chnl_b;
chnl_a.mgNo = pMgA->mgNo;
chnl_a.portNo = pMgA->portNo;
chnl_a.chlNo = 1;
chnl_a.connectNo = 0 ;
chnl_b.mgNo = pMgB->mgNo;
chnl_b.portNo = pMgB->portNo;
chnl_b.chlNo = 1;
chnl_b.connectNo = 0 ;
MGC_DEBUG("enter %s", __FUNCTION__);
tandemId = mgc_get_idle_tandem_id();
pOpera->userPort++;
ret = mgc_bind_chnl_to_tandem(pOpera->userPort , chnl_b ,tandemId);
CU_ASSERT(ret >= 0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 10);
MGC_DEBUG("connect chnl_a to aas");
pOpera->userPort++;
ret = mgc_connect_AAS(pOpera->userPort , chnl_b , chnl_a , 8 , 1 ,3);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 60);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 10);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 10);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
return;
}
void test_mgc_tandem_fork(void)
{
int ret , tandemId;
opera_struct *pOpera = &testOpera;
test_mg *pMgA = &mgA;
CHNL chnl_a;
test_mg *pMgB = &mgB;
CHNL chnl_b;
CHNL chnl_c;
CHNL chnl_tandem;
CHNL chnl_fork;
MGC_DEBUG("enter %s", __FUNCTION__);
chnl_a.mgNo = pMgA->mgNo;
chnl_a.portNo = pMgA->portNo;
chnl_a.chlNo = 1;
chnl_a.connectNo = 0 ;
chnl_b.mgNo = pMgB->mgNo;
chnl_b.portNo = pMgB->portNo;
chnl_b.chlNo = 1;
chnl_b.connectNo = 0 ;
chnl_c.mgNo = pMgB->mgNo;
chnl_c.portNo = pMgB->portNo;
chnl_c.chlNo = 2;
chnl_c.connectNo = 0;
tandemId = mgc_get_idle_tandem_id();
pOpera->userPort++;
ret = mgc_bind_chnl_to_tandem(pOpera->userPort , chnl_a ,tandemId);
CU_ASSERT(ret >= 0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_a , chnl_b , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_b , chnl_a , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
mgc_get_tandem_near_end(tandemId , &chnl_tandem);
ret = mgc_fork_chnl(pOpera->userPort , chnl_tandem , &chnl_fork);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_c , chnl_fork, 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_connect_chnl(pOpera->userPort , chnl_fork, chnl_c , 0);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 5);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
pOpera->status = OPERA_STATE_SEND;
test_mgc_wait_time(pOpera , 45);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_a);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_b);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_dlcx_chnl(pOpera->userPort , chnl_c);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
pOpera->userPort++;
ret = mgc_delete_tandem(pOpera->userPort , tandemId);
MGC_DEBUG("ret %d" , ret);
CU_ASSERT_FATAL(ret>=0);
pOpera->status = OPERA_STATE_SEND;
pOpera->result = MGC_OPER_FAILURE;
test_mgc_wait_time(pOpera, 2);
CU_ASSERT_EQUAL_FATAL(pOpera->status ,OPERA_STATE_GET);
CU_ASSERT_EQUAL_FATAL(pOpera->result ,MGC_OPER_SUCCESS);
return;
}
void test_mgc_sur_info_list(void)
{
int i,j, repeat;
MGC_SUR_INFO_LIST list;
MGC_SUR_INFO_NODE *pNode;
CONNECT_INFO *pConn;
BOOL result;
repeat = MGC_MAX_NUM_OF_SURVEILLANCE_CONN; //0
mgc_sur_info_list_init(&list);
CU_ASSERT_PTR_NULL(list.pHead);
CU_ASSERT_EQUAL(list.len, 0);
for(i=0 ; i< repeat; i++)
{
pConn = &mgcSurvillanceConn[i];
result = mgc_sur_info_add_conn_to_list(&list, pConn);
CU_ASSERT_TRUE(result);
CU_ASSERT_EQUAL(list.len, i+1);
}
pConn = &mgcSurvillanceConn[5];
pNode = mgc_sur_info_find_conn_in_list(&list, pConn);
CU_ASSERT_PTR_NOT_NULL(pNode);
CU_ASSERT_EQUAL(pNode->id, 5);
/*
for(i=0 ; i< repeat; i++)
{
pConn = &mgcSurvillanceConn[i];
j = list.len;
result = mgc_sur_info_remove_conn_to_list(&list, pConn);
CU_ASSERT_TRUE(result);
CU_ASSERT_EQUAL(list.len, j-1);
}
*/
mgc_sur_info_clear_list(&list);
CU_ASSERT_PTR_NULL(list.pHead);
CU_ASSERT_EQUAL(list.len, 0);
return;
}
CU_BOOL mgc_add_test(void)
{
CU_pSuite pSuite = NULL;
pSuite = CU_add_suite("MGC_TEST", mgc_test_cunit_init , mgc_cunit_clean);
if(NULL == pSuite)
return CU_FALSE;
if((NULL == CU_add_test(pSuite, "test of mgc init", test_mgc_init))||
/* (NULL == CU_add_test(pSuite, "test of mgc bind and unbind", test_mgc_sap_bind_and_unbind))||
(NULL == CU_add_test(pSuite, "test of mg create and delete", test_mgc_mg_create_and_delete))||
(NULL == CU_add_test(pSuite, "test of mg create and delete twice", test_mgc_mg_create_twice))||
(NULL == CU_add_test(pSuite, "test of mg port add and delete", test_mgc_port_add_and_delete))|| */
// (NULL == CU_add_test(pSuite, "test of mg create mgA", test_mgc_create_mg_a))||
// (NULL == CU_add_test(pSuite, "test of mg create mgB", test_mgc_create_mg_b))||
// (NULL == CU_add_test(pSuite, "test of create aas mg and mgc ", test_mgc_create_aas_mg_and_mgc))||
// (NULL == CU_add_test(pSuite, "test of mg create tandem", test_mgc_create_tandem))||
(NULL == CU_add_test(pSuite, "test of sur info lis operatioin", test_mgc_sur_info_list))
// (NULL == CU_add_test(pSuite, "test of mg crcx and dlcx", test_mgc_crcx_and_dlcx))
// (NULL == CU_add_test(pSuite, "test of mg connect", test_mgc_connect))
// (NULL == CU_add_test(pSuite, "test of connect aas ", test_mgc_connect_aas))||
// (NULL == CU_add_test(pSuite, "test of rtp proxy connect tone ", test_mgc_connect_tone))
// (NULL == CU_add_test(pSuite, "test of mg connect tandem to connection", test_mgc_connect_tandem_to_connection))
// (NULL == CU_add_test(pSuite, "test of mg connect connection to tandem", test_mgc_connect_connection_to_tandem))
// (NULL == CU_add_test(pSuite, "test of mg connect tandem to tandem", test_mgc_connect_tandem_to_tandem))
// (NULL == CU_add_test(pSuite, "test of mg connect tandem to aas", test_mgc_connect_tandem_to_aas))
// (NULL == CU_add_test(pSuite, "test of tandem fork", test_mgc_tandem_fork))
)
return CU_FALSE;
return CU_TRUE;
}
int main(int argc, char* argv[])
{
CU_BOOL Run = CU_FALSE ;
setvbuf(stdout, NULL, _IONBF, 0);
if (argc > 1) {
if (!strcmp("-i", argv[1])) {
Run = CU_TRUE ;
CU_set_error_action(CUEA_IGNORE);
}
else if (!strcmp("-f", argv[1])) {
Run = CU_TRUE ;
CU_set_error_action(CUEA_FAIL);
}
else if (!strcmp("-A", argv[1])) {
Run = CU_TRUE ;
CU_set_error_action(CUEA_ABORT);
}
else if (!strcmp("-e", argv[1])) {
//print_example_results();
}
else {
printf("\nUsage: AutomatedTest [option]\n\n"
" Options: -i Run, ignoring framework errors [default].\n"
" -f Run, failing on framework error.\n"
" -A Run, aborting on framework error.\n"
" -e Print expected test results and exit.\n"
" -h Print this message.\n\n");
}
}
else {
Run = CU_TRUE;
CU_set_error_action(CUEA_IGNORE);
}
if (CU_TRUE == Run) {
if (CU_initialize_registry()) {
printf("\nInitialization of Test Registry failed.");
}
else {
if(mgc_add_test() == CU_FALSE)
{
CU_cleanup_registry();
CU_get_error();
}
CU_set_output_filename("mgc_unit_test");
CU_list_tests_to_file();
CU_automated_run_tests();
CU_cleanup_registry();
}
}
return 1;
}
Reference in New Issue View Git Blame Copy Permalink