From 6cf28617aec735a578731b2a7e0d184223f18cda Mon Sep 17 00:00:00 2001 From: dhirajverma Date: Wed, 23 Jun 2021 04:53:34 -0400 Subject: [PATCH] FC and LC coverage of E2 Signed-off-by: dhirajverma Change-Id: I64f983da091055ccf15366efad086ad67d9af76f Signed-off-by: dhirajverma --- RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp | 375 +++++++++++++++++++++++++-- RIC-E2-TERMINATION/sctpThread.cpp | 46 +++- RIC-E2-TERMINATION/sctpThread.h | 7 + 3 files changed, 399 insertions(+), 29 deletions(-) diff --git a/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp b/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp index 858a337..6858868 100644 --- a/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp +++ b/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp @@ -2,11 +2,31 @@ #include #include "sctpThread.h" #include -#include"E2AP-PDU.h" +#include "E2AP-PDU.h" using namespace testing; +typedef struct { + int32_t mtype; // message type ("long" network integer) + int32_t plen; // payload length (sender data length in payload) + int32_t rmr_ver; // our internal message version number + unsigned char xid[RMR_MAX_XID]; // space for user transaction id or somesuch + unsigned char sid[RMR_MAX_SID]; // sender ID for return to sender needs + unsigned char src[RMR_MAX_SRC]; // name:port of the sender (source) + unsigned char meid[RMR_MAX_MEID]; // managed element id. + struct timespec ts; // timestamp ??? + int32_t flags; // HFL_* constants + int32_t len0; // length of the RMr header data + int32_t len1; // length of the tracing data + int32_t len2; // length of data 1 (d1) + int32_t len3; // length of data 2 (d2) + int32_t sub_id; // subscription id (-1 invalid) + + unsigned char srcip[RMR_MAX_SRC]; // ip address and port of the source +} uta_mhdr_t; + TEST(sctp, TEST1) { + mdclog_level_set(MDCLOG_DEBUG); string s; s = translateRmrErrorMessages(0); EXPECT_THAT(s, HasSubstr("RMR_OK")); @@ -49,8 +69,7 @@ TEST(sctp, TEST1) { auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t)); TEST(sctp, TEST2) { - struct epoll_event event; - int epoll_fd = epoll_create1(0); + struct epoll_event event; event.events = EPOLLIN; event.data.fd = 0; ConnectedCU_t data1; @@ -64,8 +83,7 @@ TEST(sctp, TEST2) { } TEST(sctp, TEST3) { - struct epoll_event event; - int epoll_fd = epoll_create1(0); + struct epoll_event event; event.events = EPOLLIN; event.data.fd = 0; ConnectedCU_t data1; @@ -80,41 +98,352 @@ TEST(sctp, TEST3) { handlepoll_error(event,reporting_msg,rmrmessagesbuffer,sctp); } - TEST(sctp, TEST4) { + ConnectedCU_t cu; + ConnectedCU_t* connected_cu = &cu; + Sctp_Map_t m1; + Sctp_Map_t *m = &m1; + cleanHashEntry(connected_cu,m); +} + +TEST(sctp, TEST5) { + sctp_params_t sctp_ut_params; + sctp_params_t* sctp = &sctp_ut_params; + sctp->configFilePath.assign("/opt/e2/RIC-E2-TERMINATION/config/"); + sctp->configFileName.assign("config.conf"); + handleConfigChange(sctp); +} + +TEST(sctp, TEST6) { + int epoll_fd = epoll_create1(0); + ConnectedCU_t cu; + ConnectedCU_t* peerinfo = &cu; + Sctp_Map_t m1; + Sctp_Map_t *m = &m1; + modifyToEpoll(epoll_fd,peerinfo,2,m, (char*)"enodeb1",2); +} -ConnectedCU_t cu; -ConnectedCU_t* connected_cu = &cu; -Sctp_Map_t m1; -Sctp_Map_t *m = &m1; -cleanHashEntry(connected_cu,m); +/* TEST7 Begin: */ +void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer); +} +void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication; + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*)); + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 1; + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs); + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs)); + RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]; + ie->id = ProtocolIE_ID_id_RICrequestID; + ie->value.present = RICindication_IEs__value_PR_RICrequestID; + ie->value.choice.RICrequestID.ricRequestorID = 12345; + ie->value.choice.RICrequestID.ricInstanceID = 1; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer); } -TEST(sctp, TEST5) { +void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { -sctp_params_t sctp_ut_params; -sctp_params_t* sctp = &sctp_ut_params; -handleConfigChange(sctp); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer); } +void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer); +} +TEST(sctp, TEST7) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, 0, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, 0, sizeof(message)); + memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + + message.peerInfo = peerInfo; + message.peerInfo->sctpParams = &sctp_ut_params; + snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb"); + + sctp_ut_params.myIP = "1.2.3.4"; + sctp_ut_params.rmrPort = 38000; + snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort)); + sctp_ut_params.prometheusRegistry = std::make_shared(); + startPrometheus(sctp_ut_params); + + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, RMRFL_NONE); + rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t)); + rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t)); + rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji "); + rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji"); -TEST(sctp, TEST6) { -int epoll_fd = epoll_create1(0); -ConnectedCU_t cu; -ConnectedCU_t* peerinfo = &cu; -Sctp_Map_t m1; -Sctp_Map_t *m = &m1; -modifyToEpoll(epoll_fd,peerinfo,2,m,"enodeb1",2); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */ + create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */ + create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */ + create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */ + create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer); + /* For Procedure's Default case. */ + pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100); + asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer); + + /* Put some usleep... */ + // usleep(2); + if(pdu.choice.initiatingMessage) + free(pdu.choice.initiatingMessage); + if(rmrMessageBuffer.sendMessage->header) + free(rmrMessageBuffer.sendMessage->header); + if(rmrMessageBuffer.sendMessage) + free(rmrMessageBuffer.sendMessage); +} + +/* TEXT8 Begin: */ +void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */ + pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset; + asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer); } +void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*)); + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 1; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t); + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t)); + RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]; + + ie->id = ProtocolIE_ID_id_RICrequestID; + ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID; + /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */ + pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICcontrol; + asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer); +} + +void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */ + pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscription; + asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer); +} + +void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ + pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete; + asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer); +} +TEST(sctp, TEST8) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + pdu.present = E2AP_PDU_PR_successfulOutcome; + pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); + memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome)); + memset( (void*)&message, 0, sizeof(message)); + memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + + message.peerInfo = peerInfo; + message.peerInfo->sctpParams = &sctp_ut_params; + snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb"); + + sctp_ut_params.myIP = "1.2.3.4"; + sctp_ut_params.rmrPort = 38000; + snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort)); + + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, RMRFL_NONE); + rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t)); + rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t)); + rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji "); + rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji"); + + /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */ + create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer); + /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */ + create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer); + /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */ + create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer); + /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ + create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer); + /* For Procedure's Default case. */ + pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100); + asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer); + + /*Put some usleep... */ + // usleep(2); + if(pdu.choice.successfulOutcome) + free(pdu.choice.successfulOutcome); + if(rmrMessageBuffer.sendMessage->header) + free(rmrMessageBuffer.sendMessage->header); + if(rmrMessageBuffer.sendMessage) + free(rmrMessageBuffer.sendMessage); +} + +/* TEST9 Begin: */ +void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*)); + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 1; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t); + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t)); + RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]; + + ie->id = ProtocolIE_ID_id_RICrequestID; + ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID; + /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */ + pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICcontrol; + asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer); +} + +void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */ + pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscription; + asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer); +} + +void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { + + /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ + pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete; + asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer); +} + +TEST(sctp, TEST9) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + pdu.present = E2AP_PDU_PR_unsuccessfulOutcome; + pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); + memset( (void*)pdu.choice.unsuccessfulOutcome, 0, sizeof(pdu.choice.unsuccessfulOutcome)); + memset( (void*)&message, 0, sizeof(message)); + memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + + message.peerInfo = peerInfo; + message.peerInfo->sctpParams = &sctp_ut_params; + snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb"); + + sctp_ut_params.myIP = "1.2.3.4"; + sctp_ut_params.rmrPort = 38000; + snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort)); + + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, RMRFL_NONE); + rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t)); + rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t)); + rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji "); + rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji"); + + /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */ + create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer); + /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */ + create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer); + /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ + create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer); + /* For Procedure's Default case. */ + pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100); + asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer); + + if(pdu.choice.unsuccessfulOutcome) + free(pdu.choice.unsuccessfulOutcome); + if(rmrMessageBuffer.sendMessage->header) + free(rmrMessageBuffer.sendMessage->header); + if(rmrMessageBuffer.sendMessage) + free(rmrMessageBuffer.sendMessage); +} + +TEST(sctp, TEST10) { + int epoll_fd = epoll_create1(0); + ConnectedCU_t cu; + ConnectedCU_t* peerinfo = &cu; + Sctp_Map_t m1; + Sctp_Map_t *m = &m1; + addToEpoll(epoll_fd, peerinfo, 2, m, (char*)"enodeb1", 0); +} + +TEST(sctp, TEST11) { + sctp_params_t sctpParams; + int argc = 5; + char **argv = (char**) malloc(argc * sizeof(char*)); + argv[0] = "./e2"; + argv[1] = "-p"; + argv[2] = "/opt/e2/RIC-E2-TERMINATION/config/"; + argv[3] = "-f"; + argv[4] = "config.conf"; + + auto result = parse(argc, argv, sctpParams); + sctpParams.podName.assign("E2TermAlpha_pod"); + buildConfiguration(sctpParams); + sctpParams.epoll_fd = epoll_create1(0); + // getRmrContext(sctpParams); + buildInotify(sctpParams); + buildListeningPort(sctpParams); + sctpParams.sctpMap = new mapWrapper(); + listener(&sctpParams); +} + +TEST(sctp, TEST12) { + ReportingMessages_t reporting_msg; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + sendSctpMsg(peerInfo, reporting_msg, sctpMap); +} + +/*TEST(sctp, TEST13) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + pdu.present = E2AP_PDU_PR_successfulOutcome; + pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); + memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome)); + memset( (void*)&message, 0, sizeof(message)); + memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + + message.peerInfo = peerInfo; + message.peerInfo->sctpParams = &sctp_ut_params; + snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb"); + + sctp_ut_params.myIP = "1.2.3.4"; + sctp_ut_params.rmrPort = 38000; + snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort)); + rmrMessageBuffer.rcvMessage = rmr_rcv_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.rcvMessage); + rmr_get_meid(rmrMessageBuffer.rcvMessage, (unsigned char *)message.message.enodbName); + message.peerInfo = (ConnectedCU_t *) sctpMap->find(message.message.enodbName); + pdu.choice.successfulOutcome->procedureCode = ProcedureCode_id_E2setup; + receiveXappMessages(sctp_ut_params.sctpMap, rmrMessageBuffer, message.message.time); +}*/ int main(int argc, char **argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } - diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp index 207ff9f..882ffdf 100644 --- a/RIC-E2-TERMINATION/sctpThread.cpp +++ b/RIC-E2-TERMINATION/sctpThread.cpp @@ -197,6 +197,7 @@ int buildConfiguration(sctp_params_t &sctpParams) { } std::string pod = conf.getStringValue("pod_name"); +#ifndef UNIT_TEST if (pod.length() == 0) { mdclog_write(MDCLOG_ERR, "illegal pod_name in config file"); return -1; @@ -213,7 +214,7 @@ int buildConfiguration(sctp_params_t &sctpParams) { return -1; } } - +#endif tmpStr = conf.getStringValue("trace"); transform(tmpStr.begin(), tmpStr.end(), tmpStr.begin(), ::tolower); if ((tmpStr.compare("start")) == 0) { @@ -297,6 +298,9 @@ void startPrometheus(sctp_params_t &sctpParams) { int main(const int argc, char **argv) { sctp_params_t sctpParams; +#else + int e2_test_main(const int argc, char **argv, sctp_params_t &sctpParams) { +#endif { std::random_device device{}; @@ -347,8 +351,9 @@ int main(const int argc, char **argv) { mdclog_write(MDCLOG_ERR, "failed to open epoll descriptor"); exit(-1); } - +#ifndef UNIT_TEST getRmrContext(sctpParams); +#endif if (sctpParams.rmrCtx == nullptr) { close(sctpParams.epoll_fd); exit(-1); @@ -396,7 +401,6 @@ int main(const int argc, char **argv) { return 0; } -#endif void handleTermInit(sctp_params_t &sctpParams) { sendTermInit(sctpParams); //send to e2 manager init of e2 term @@ -576,7 +580,11 @@ void listener(sctp_params_t *params) { if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Start EPOLL Wait. Timeout = %d", params->epollTimeOut); } +#ifndef UNIT_TEST auto numOfEvents = epoll_wait(params->epoll_fd, events, MAXEVENTS, params->epollTimeOut); +#else + auto numOfEvents = 1; +#endif if (numOfEvents == 0) { // time out if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "got epoll timeout"); @@ -701,6 +709,9 @@ void listener(sctp_params_t *params) { end.tv_nsec - start.tv_nsec); } } +#ifdef UNIT_TEST + break; +#endif } } @@ -988,7 +999,9 @@ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_ mdclog_write(MDCLOG_ERR, "error writing to CU a message, %s ", strerror(errno)); if (!peerInfo->isConnected) { mdclog_write(MDCLOG_ERR, "connection to CU %s is still in progress.", message.message.enodbName); +#ifndef UNIT_TEST return -1; +#endif } cleanHashEntry(peerInfo, m); close(fd); @@ -1003,7 +1016,9 @@ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_ free(tmp); } m->erase(key); +#ifndef UNIT_TEST return -1; +#endif } message.message.direction = 'D'; // send report.buffer of size @@ -1634,9 +1649,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, string messageName("RICserviceUpdate"); string ieName("RICserviceUpdateIEs"); message.message.messageType = RIC_SERVICE_UPDATE; +#ifndef UNIT_TEST message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment((double)message.message.asnLength); - +#endif buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); break; } @@ -1644,8 +1660,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got ErrorIndication %s", message.message.enodbName); } +#ifndef UNIT_TEST message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_ERROR_INDICATION, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "RIC_ERROR_INDICATION failed to send to xAPP"); } @@ -1655,9 +1673,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got Reset %s", message.message.enodbName); } - +#ifndef UNIT_TEST message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); +#endif if (XML_From_PER(message, rmrMessageBuffer) < 0) { break; } @@ -1700,8 +1719,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, ie->value.choice.RICrequestID.ricInstanceID, ie->value.choice.RICrequestID.ricRequestorID); } +#ifndef UNIT_TEST message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICindication]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICindication]->Increment((double)message.message.asnLength); +#endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; } else { @@ -1745,8 +1766,10 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got Reset %s", message.message.enodbName); } +#ifndef UNIT_TEST message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); +#endif if (XML_From_PER(message, rmrMessageBuffer) < 0) { break; } @@ -1782,9 +1805,10 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, rmr_bytes2meid(rmrMessageBuffer.sendMessage, (unsigned char *)message.message.enodbName, strlen(message.message.enodbName)); - +#ifndef UNIT_TEST message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); +#endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; } else { @@ -1802,8 +1826,10 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscription %s", message.message.enodbName); } +#ifndef UNIT_TEST message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_SUB_RESP, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription successful message failed to send to xAPP"); } @@ -1813,8 +1839,10 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscriptionDelete %s", message.message.enodbName); } +#ifndef UNIT_TEST message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_SUB_DEL_RESP, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription delete successful message failed to send to xAPP"); } @@ -1871,8 +1899,10 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, strlen((const char *) tx)); rmr_bytes2meid(rmrMessageBuffer.sendMessage, (unsigned char *) message.message.enodbName, strlen(message.message.enodbName)); +#ifndef UNIT_TEST message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); +#endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; } else { @@ -1889,8 +1919,10 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscription %s", message.message.enodbName); } +#ifndef UNIT_TEST message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_SUB_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription unsuccessful message failed to send to xAPP"); } @@ -1900,8 +1932,10 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscriptionDelete %s", message.message.enodbName); } +#ifndef UNIT_TEST message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_SUB_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription Delete unsuccessful message failed to send to xAPP"); } diff --git a/RIC-E2-TERMINATION/sctpThread.h b/RIC-E2-TERMINATION/sctpThread.h index 6e22f7b..f67f3e4 100644 --- a/RIC-E2-TERMINATION/sctpThread.h +++ b/RIC-E2-TERMINATION/sctpThread.h @@ -411,6 +411,8 @@ void buildJsonMessage(ReportingMessages_t &message); */ string translateRmrErrorMessages(int state); +int buildConfiguration(sctp_params_t &sctpParams); +void startPrometheus(sctp_params_t &sctpParams); static inline uint64_t rdtscp(uint32_t &aux) { uint64_t rax,rdx; @@ -421,4 +423,9 @@ static inline uint64_t rdtscp(uint32_t &aux) { #define RIC_SCTP_CONNECTION_FAILURE 10080 #endif +#ifdef UNIT_TEST +int e2_test_main(const int argc, char **argv, sctp_params_t &sctpParams); +int buildListeningPort(sctp_params_t &sctpParams); +#endif + #endif //X2_SCTP_THREAD_H -- 2.16.6