LC and FC for E2 to Oran

Signed-off-by: dhirajverma <dhiraj.verma@nokia.com>
Change-Id: I6a00d0660f0c4e52c48991218a2dcb7bc4694fc3

diff --git a/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp b/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp
index 6858868..b2be086 100644 (file)
--- a/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp
+++ b/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp
@@ -123,18 +123,77 @@ TEST(sctp, TEST6) {
     modifyToEpoll(epoll_fd,peerinfo,2,m, (char*)"enodeb1",2);
 }
 
+
 /* TEST7 Begin: */
-void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
+void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) {
+    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.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 NOKIA ");
+    rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA");
+}
+
+void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
     
+    if( (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) &&
+        (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]) ) {
+        free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]);
+        pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = NULL;
+    }
+    if(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) {
+        free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array);
+        pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = NULL;
+    }
+    pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 0;
+    pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = 0;
+    
+    if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
+        free(rmrMessageBuffer.sendMessage->header);
+        rmrMessageBuffer.sendMessage->header = NULL;
+    }
+    if(rmrMessageBuffer.sendMessage->payload) {
+        free(rmrMessageBuffer.sendMessage->payload);
+        rmrMessageBuffer.sendMessage->payload = NULL;
+    }
+    if(rmrMessageBuffer.sendMessage) {
+        free(rmrMessageBuffer.sendMessage);
+        rmrMessageBuffer.sendMessage = NULL;
+    }
+    if(rmrMessageBuffer.rmrCtx) {
+        rmr_close(rmrMessageBuffer.rmrCtx);
+        rmrMessageBuffer.rmrCtx = NULL;
+    }
+}
+
+void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu, 
+        Sctp_Map_t *sctpMap, 
+        ReportingMessages_t &message, 
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
+
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* 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);
+    delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
 }
 
-void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
+void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, 
+        Sctp_Map_t *sctpMap, 
+        ReportingMessages_t &message, 
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
     
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* 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;
@@ -149,22 +208,35 @@ void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, Sctp_Map_t
     ie->value.choice.RICrequestID.ricInstanceID = 1;
 
     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
+    delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
 }
 
-void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
+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) {
 
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* 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);
+    delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
 }
 
-void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
-    
+void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu, 
+        Sctp_Map_t *sctpMap, 
+        ReportingMessages_t &message, 
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
+
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* 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);
+    delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
 }
 
 TEST(sctp, TEST7) {
@@ -173,61 +245,95 @@ TEST(sctp, TEST7) {
     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<Registry>();
-    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");
+
+    snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
+    rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
 
     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
-    create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
-    create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
-    create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
-    create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* 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)
+    if(pdu.choice.initiatingMessage) {
         free(pdu.choice.initiatingMessage);
-    if(rmrMessageBuffer.sendMessage->header)
+        pdu.choice.initiatingMessage = NULL;
+    }
+    if(sctpMap) {
+        delete sctpMap;
+        sctpMap = NULL;
+    }
+}
+
+/* TEST8 Begin: */
+void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
+
+    if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) && 
+        (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]) ) {
+        free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]);
+        pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = NULL;
+    }
+    if(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) {
+        free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array);
+        pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = NULL;
+    }
+    pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 0;
+    pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = 0;
+
+    if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
         free(rmrMessageBuffer.sendMessage->header);
-    if(rmrMessageBuffer.sendMessage)
+        rmrMessageBuffer.sendMessage->header = NULL;
+    }
+    if(rmrMessageBuffer.sendMessage->payload) {
+        free(rmrMessageBuffer.sendMessage->payload);
+        rmrMessageBuffer.sendMessage->payload = NULL;
+    }
+#if 0
+    if(rmrMessageBuffer.rmrCtx) {
+        rmr_close(rmrMessageBuffer.rmrCtx);
+        rmrMessageBuffer.rmrCtx = NULL;
+    }
+#endif
+    if(rmrMessageBuffer.sendMessage) {
         free(rmrMessageBuffer.sendMessage);
+        rmrMessageBuffer.sendMessage = NULL;
+    }
 }
 
-/* TEXT8 Begin: */
-void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
+
+void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu,
+        Sctp_Map_t *sctpMap,
+        ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
     
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset; 
     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
+    delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 }
 
-void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
+void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
+        Sctp_Map_t *sctpMap,
+        ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
 
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
+    
     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);
@@ -239,20 +345,33 @@ void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, Sctp_Map_t *s
     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICcontrol; 
     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
+    delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 }
 
-void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
-    
+void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
+        Sctp_Map_t *sctpMap,
+        ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
+
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscription; 
     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
+    delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 }
 
-void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
-    
+void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
+        Sctp_Map_t *sctpMap, 
+        ReportingMessages_t &message, 
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
+
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete; 
     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
+    delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 }
 
 TEST(sctp, TEST8) {
@@ -261,52 +380,80 @@ TEST(sctp, TEST8) {
     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");
-    
+
+    snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
+
     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
-    create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
-    create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
-    create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
-    create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* 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)
+    
+    if(pdu.choice.successfulOutcome) {
         free(pdu.choice.successfulOutcome);
-    if(rmrMessageBuffer.sendMessage->header)
+        pdu.choice.successfulOutcome = NULL;
+    }
+    if(sctpMap) {
+        delete sctpMap;
+        sctpMap = NULL;
+    }
+}
+
+/* TEST9 Begin: */
+void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
+
+    if( (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) &&
+        (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]) ) {
+        free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]);
+        pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = NULL;
+    }
+    if(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) {
+        free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array);
+        pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = NULL;
+    }
+    pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 0;
+    pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = 0;
+
+    if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
         free(rmrMessageBuffer.sendMessage->header);
-    if(rmrMessageBuffer.sendMessage)
+        rmrMessageBuffer.sendMessage->header = NULL;
+    }
+    if(rmrMessageBuffer.sendMessage->payload) {
+        free(rmrMessageBuffer.sendMessage->payload);
+        rmrMessageBuffer.sendMessage->payload = NULL;
+    }
+#if 0
+    if(rmrMessageBuffer.rmrCtx) {
+        rmr_close(rmrMessageBuffer.rmrCtx);
+        rmrMessageBuffer.rmrCtx = NULL;
+    }
+#endif
+    if(rmrMessageBuffer.sendMessage) {
         free(rmrMessageBuffer.sendMessage);
+        rmrMessageBuffer.sendMessage = NULL;
+    }
 }
 
-/* TEST9 Begin: */
-void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
+void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, 
+        Sctp_Map_t *sctpMap, 
+        ReportingMessages_t &message, 
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
 
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
+    
     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);
@@ -318,20 +465,33 @@ void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, Sctp_Map_t
     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
+    delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 }
 
-void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
-    
+void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu, 
+        Sctp_Map_t *sctpMap, 
+        ReportingMessages_t &message, 
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
+
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscription; 
     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
+    delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 }
 
-void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
+void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, 
+        Sctp_Map_t *sctpMap, 
+        ReportingMessages_t &message, 
+        RmrMessagesBuffer_t &rmrMessageBuffer,
+        sctp_params_t &sctp_ut_params) {
     
+    init_memories(message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete; 
     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
+    delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 }
 
 TEST(sctp, TEST9) {
@@ -340,45 +500,36 @@ TEST(sctp, TEST9) {
     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");
+    snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
 
     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
-    create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
-    create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
-    create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer);
+    create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
     /* For Procedure's Default case. */
     pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100); 
     asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
-
-    if(pdu.choice.unsuccessfulOutcome)
+    
+    if(pdu.choice.unsuccessfulOutcome) {
         free(pdu.choice.unsuccessfulOutcome);
-    if(rmrMessageBuffer.sendMessage->header)
-        free(rmrMessageBuffer.sendMessage->header);
-    if(rmrMessageBuffer.sendMessage)
-        free(rmrMessageBuffer.sendMessage);
+        pdu.choice.unsuccessfulOutcome = NULL;
+    }
+    if(sctpMap) {
+        delete sctpMap;
+        sctpMap = NULL;
+    }
 }
 
+
 TEST(sctp, TEST10) {
     int epoll_fd = epoll_create1(0);
     ConnectedCU_t cu;
@@ -391,56 +542,230 @@ TEST(sctp, TEST10) {
 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";
+    char **argv = (char**) calloc(argc, sizeof(char*));
+    argv[0] = (char*) malloc(40 * sizeof(char));
+    argv[1] = (char*) malloc(40 * sizeof(char));
+    argv[2] = (char*) malloc(40 * sizeof(char));
+    argv[3] = (char*) malloc(40 * sizeof(char));
+    argv[4] = (char*) malloc(40 * sizeof(char));
+    snprintf(argv[0], strlen("./e2 "), "%s", (char*)"./e2");
+    snprintf(argv[1], strlen("-p "), "%s", (char*)"-p");
+    snprintf(argv[2], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config");
+    snprintf(argv[3], strlen("-f "), "%s", (char*)"-f");
+    snprintf(argv[4], strlen("config.conf "), "%s", (char*)"config.conf");
     
     auto result = parse(argc, argv, sctpParams);
     sctpParams.podName.assign("E2TermAlpha_pod");
-    buildConfiguration(sctpParams);
+    sctpParams.sctpMap = new mapWrapper();
     sctpParams.epoll_fd = epoll_create1(0);
+    buildConfiguration(sctpParams);
     // getRmrContext(sctpParams);
     buildInotify(sctpParams);
     buildListeningPort(sctpParams);
-    sctpParams.sctpMap = new mapWrapper();
     listener(&sctpParams);
+
+    if(sctpParams.sctpMap) {
+        delete sctpParams.sctpMap;
+        sctpParams.sctpMap = NULL;
+    }
+    if(argv) {
+        free(argv[0]);
+        argv[0] = NULL;
+        free(argv[1]);
+        argv[1] = NULL;
+        free(argv[2]);
+        argv[2] = NULL;
+        free(argv[3]);
+        argv[3] = NULL;
+        free(argv[4]);
+        argv[4] = NULL;
+        free(argv);
+        argv=NULL;
+    }
 }
 
 TEST(sctp, TEST12) {
     ReportingMessages_t     reporting_msg;
     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
     sendSctpMsg(peerInfo, reporting_msg, sctpMap);
+
+    if(sctpMap) {
+        delete sctpMap;
+        sctpMap = NULL;
+    }
 }
 
-/*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;
+/*TEST13 Begin*/
+
+void inti_buffers_rcv(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
+    message.peerInfo = peerInfo;
+    snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
+
+    rmrMessageBuffer.rcvMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
+    rmrMessageBuffer.rcvMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
+    rmrMessageBuffer.rcvMessage->len = strlen("Saying Hello from Ramji ");
+    rmrMessageBuffer.rcvMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
+
+    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");
+
+}
+
+void delete_memories_rcv(RmrMessagesBuffer_t &rmrMessageBuffer) {
+
+    if(rmrMessageBuffer.rcvMessage && rmrMessageBuffer.rcvMessage->header) {
+        free(rmrMessageBuffer.rcvMessage->header);
+        rmrMessageBuffer.rcvMessage->header = NULL;
+    }
+    if(rmrMessageBuffer.rcvMessage) {
+        free(rmrMessageBuffer.rcvMessage);
+        rmrMessageBuffer.rcvMessage = NULL;
+    }
+    if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
+        free(rmrMessageBuffer.sendMessage->header);
+        rmrMessageBuffer.sendMessage->header = NULL;
+    }
+    if(rmrMessageBuffer.sendMessage) {
+        free(rmrMessageBuffer.sendMessage);
+        rmrMessageBuffer.sendMessage = NULL;
+    }
+
+}
+
+void create_receiveXappMessages_RIC_ERROR_INDICATION(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_ERROR_INDICATION;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+
+}
+void create_receiveXappMessages_RIC_E2_SETUP_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_E2_SETUP_FAILURE;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_RIC_SUB_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_SUB_REQ;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_RIC_CONTROL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_CONTROL_REQ;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_RIC_SERVICE_QUERY(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_QUERY;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_ACK;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_FAILURE;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+
+void create_receiveXappMessages_RIC_E2_RESET_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_REQ;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_RIC_E2_RESET_RESP(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_RESP;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_SCTP_CLEAR_ALL;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_REQ;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+void create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
+        RmrMessagesBuffer_t &rmrMessageBuffer) {
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = E2_TERM_KEEP_ALIVE_REQ;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+}
+
+
+TEST(sctp, TEST13) {
+    Sctp_Map_t *sctpMap = new Sctp_Map_t();
+    ReportingMessages_t message;
+    RmrMessagesBuffer_t rmrMessageBuffer;
 
-    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");
+    // Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset
+    create_receiveXappMessages_RIC_E2_SETUP_FAILURE(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_ERROR_INDICATION(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_SUB_REQ(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_CONTROL_REQ(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_E2_RESET_RESP(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_E2_RESET_REQ(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(sctpMap, message, rmrMessageBuffer);
+    create_receiveXappMessages_RIC_SERVICE_QUERY(sctpMap, message, rmrMessageBuffer);
+
+    inti_buffers_rcv(message, rmrMessageBuffer);
+    rmrMessageBuffer.rcvMessage->mtype = 100;
+    receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
+    delete_memories_rcv(rmrMessageBuffer);
+
+    if(sctpMap) {
+        delete sctpMap;
+        sctpMap = NULL;
+    }
+}
 
-    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);

diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp
index b8a3058..2d7e76b 100644 (file)
--- a/RIC-E2-TERMINATION/sctpThread.cpp
+++ b/RIC-E2-TERMINATION/sctpThread.cpp
@@ -479,10 +479,6 @@ 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{};
         std::mt19937 generator(device());
@@ -532,9 +528,7 @@ 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);
@@ -582,6 +576,7 @@ 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
@@ -904,11 +899,17 @@ void handleConfigChange(sctp_params_t *sctpParams) {
     char buf[4096] __attribute__ ((aligned(__alignof__(struct inotify_event))));
     const struct inotify_event *event;
     char *ptr;
-
+#ifdef UNIT_TEST
+    struct inotify_event tmpEvent;
+#endif
     path p = (sctpParams->configFilePath + "/" + sctpParams->configFileName).c_str();
     auto endlessLoop = true;
     while (endlessLoop) {
-        auto len = read(sctpParams->inotifyFD, buf, sizeof buf);
+#ifndef UNIT_TEST
+    auto len = read(sctpParams->inotifyFD, buf, sizeof buf);
+#else
+    auto len=10;
+#endif
         if (len == -1) {
             if (errno != EAGAIN) {
                 mdclog_write(MDCLOG_ERR, "read %s ", strerror(errno));
@@ -922,7 +923,12 @@ void handleConfigChange(sctp_params_t *sctpParams) {
         }
 
         for (ptr = buf; ptr < buf + len; ptr += sizeof(struct inotify_event) + event->len) {
-            event = (const struct inotify_event *)ptr;
+#ifndef UNIT_TEST
+    event = (const struct inotify_event *)ptr;
+#else
+    tmpEvent.mask = (uint32_t)IN_CLOSE_WRITE;
+    event = &tmpEvent;
+#endif
             if (event->mask & (uint32_t)IN_ISDIR) {
                 continue;
             }
@@ -1006,6 +1012,9 @@ void handleConfigChange(sctp_params_t *sctpParams) {
 
                 endlessLoop = false;
             }
+#ifdef UNIT_TEST
+            break;
+#endif
         }
     }
 }
@@ -1488,8 +1497,9 @@ static void buildAndSendSetupRequest(ReportingMessages_t &message,
     static unsigned char tx[32];
     snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++);
     rmr_bytes2xact(rmrMsg, tx, strlen((const char *) tx));
-
+#ifndef UNIT_TEST
     rmrMsg = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMsg);
+#endif
     if (rmrMsg == nullptr) {
         mdclog_write(MDCLOG_ERR, "RMR failed to send returned nullptr");
     } else if (rmrMsg->state != 0) {
@@ -1499,7 +1509,9 @@ static void buildAndSendSetupRequest(ReportingMessages_t &message,
             rmrMsg->state = 0;
             mdclog_write(MDCLOG_INFO, "RETRY sending Message %d to Xapp from %s",
                          rmrMsg->mtype, rmr_get_meid(rmrMsg, (unsigned char *) meid));
+#ifndef UNIT_TEST
             rmrMsg = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMsg);
+#endif
             if (rmrMsg == nullptr) {
                 mdclog_write(MDCLOG_ERR, "RMR failed send returned nullptr");
             } else if (rmrMsg->state != 0) {
@@ -2282,6 +2294,9 @@ int receiveXappMessages(Sctp_Map_t *sctpMap,
 
     // get message payload
     //auto msgData = msg->payload;
+#ifdef UNIT_TEST
+        rmrMessageBuffer.rcvMessage->state = 0;
+#endif
     if (rmrMessageBuffer.rcvMessage->state != 0) {
         mdclog_write(MDCLOG_ERR, "RMR Receiving message with stat = %d", rmrMessageBuffer.rcvMessage->state);
         return -1;
@@ -2508,7 +2523,9 @@ int receiveXappMessages(Sctp_Map_t *sctpMap,
             static unsigned char tx[32];
             auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++);
             rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, txLen);
+#ifndef UNIT_TEST
             rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage);
+#endif
             if (rmrMessageBuffer.sendMessage == nullptr) {
                 rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
                 mdclog_write(MDCLOG_ERR, "Failed to send E2_TERM_KEEP_ALIVE_RESP RMR message returned NULL");
@@ -2703,9 +2720,11 @@ int modifyToEpoll(int epoll_fd,
 
 int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &message) {
     buildJsonMessage(message);
-
+#ifndef UNIT_TEST
     rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage);
-
+#else
+        rmrMessageBuffer.sendMessage->state = RMR_ERR_RETRY;
+#endif
     if (rmrMessageBuffer.sendMessage == nullptr) {
         rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
         mdclog_write(MDCLOG_ERR, "RMR failed send message returned with NULL pointer");
@@ -2720,7 +2739,9 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m
             mdclog_write(MDCLOG_INFO, "RETRY sending Message type %d to Xapp from %s",
                          rmrMessageBuffer.sendMessage->mtype,
                          rmr_get_meid(rmrMessageBuffer.sendMessage, (unsigned char *)meid));
+#ifndef UNIT_TEST
             rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage);
+#endif
             if (rmrMessageBuffer.sendMessage == nullptr) {
                 mdclog_write(MDCLOG_ERR, "RMR failed send message returned with NULL pointer");
                 rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE);
@@ -2746,6 +2767,9 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m
 }
 
 void buildJsonMessage(ReportingMessages_t &message) {
+#ifdef UNIT_TEST
+        jsonTrace = true;
+#endif
     if (jsonTrace) {
         message.outLen = sizeof(message.base64Data);
         base64::encode((const unsigned char *) message.message.asndata,

diff --git a/RIC-E2-TERMINATION/sctpThread.h b/RIC-E2-TERMINATION/sctpThread.h
index 4cd494a..02af0f0 100644 (file)
--- a/RIC-E2-TERMINATION/sctpThread.h
+++ b/RIC-E2-TERMINATION/sctpThread.h
@@ -430,7 +430,8 @@ static inline uint64_t rdtscp(uint32_t &aux) {
 #endif
 
 #ifdef UNIT_TEST
-int e2_test_main(const int argc, char **argv, sctp_params_t &sctpParams);
+int buildConfiguration(sctp_params_t &sctpParams);
+void startPrometheus(sctp_params_t &sctpParams);
 int buildListeningPort(sctp_params_t &sctpParams);
 #endif