RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp

   1 #include <gtest/gtest.h>
   2 #include <gmock/gmock.h>
   3 #include "sctpThread.h"
   4 #include <sys/epoll.h>
   5 #include "E2AP-PDU.h"
   6
   7 using namespace testing;
   8
   9 typedef struct {
  10     int32_t mtype;                      // message type  ("long" network integer)
  11     int32_t     plen;                       // payload length (sender data length in payload)
  12     int32_t rmr_ver;                    // our internal message version number
  13     unsigned char xid[RMR_MAX_XID];         // space for user transaction id or somesuch
  14     unsigned char sid[RMR_MAX_SID];         // sender ID for return to sender needs
  15     unsigned char src[RMR_MAX_SRC];         // name:port of the sender (source)
  16     unsigned char meid[RMR_MAX_MEID];   // managed element id.
  17     struct timespec     ts;                 // timestamp ???
  18     int32_t     flags;                      // HFL_* constants
  19     int32_t     len0;                       // length of the RMr header data
  20     int32_t     len1;                       // length of the tracing data
  21     int32_t     len2;                       // length of data 1 (d1)
  22     int32_t     len3;                       // length of data 2 (d2)
  23     int32_t     sub_id;                     // subscription id (-1 invalid)
  24
  25     unsigned char srcip[RMR_MAX_SRC];   // ip address and port of the source
  26 } uta_mhdr_t;
  27
  28 TEST(sctp, TEST1) {
  29     mdclog_level_set(MDCLOG_DEBUG);
  30     string s;
  31     s = translateRmrErrorMessages(0);
  32     EXPECT_THAT(s, HasSubstr("RMR_OK"));
  33     s = translateRmrErrorMessages(1);
  34     EXPECT_THAT(s, HasSubstr("RMR_ERR_BADARG"));
  35     s = translateRmrErrorMessages(2);
  36     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOENDPT"));
  37     s = translateRmrErrorMessages(3);
  38     EXPECT_THAT(s, HasSubstr("RMR_ERR_EMPTY"));
  39     s = translateRmrErrorMessages(4);
  40     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOHDR"));
  41     s = translateRmrErrorMessages(5);
  42     EXPECT_THAT(s, HasSubstr("RMR_ERR_SENDFAILED"));
  43     s = translateRmrErrorMessages(6);
  44     EXPECT_THAT(s, HasSubstr("RMR_ERR_CALLFAILED"));
  45     s = translateRmrErrorMessages(7);
  46     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOWHOPEN"));
  47     s = translateRmrErrorMessages(8);
  48     EXPECT_THAT(s, HasSubstr("RMR_ERR_WHID"));
  49     s = translateRmrErrorMessages(9);
  50     EXPECT_THAT(s, HasSubstr("RMR_ERR_OVERFLOW"));
  51     s = translateRmrErrorMessages(10);
  52     EXPECT_THAT(s, HasSubstr("RMR_ERR_RETRY"));
  53     s = translateRmrErrorMessages(11);
  54     EXPECT_THAT(s, HasSubstr("RMR_ERR_RCVFAILED"));
  55     s = translateRmrErrorMessages(12);
  56     EXPECT_THAT(s, HasSubstr("RMR_ERR_TIMEOUT"));
  57     s = translateRmrErrorMessages(13);
  58     EXPECT_THAT(s, HasSubstr("RMR_ERR_UNSET"));
  59     s = translateRmrErrorMessages(14);
  60     EXPECT_THAT(s, HasSubstr("RMR_ERR_TRUNC"));
  61     s = translateRmrErrorMessages(15);
  62     EXPECT_THAT(s, HasSubstr("RMR_ERR_INITFAILED"));
  63     s = translateRmrErrorMessages(16);
  64     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOTSUPP"));
  65     s = translateRmrErrorMessages(17);
  66     EXPECT_THAT(s, HasSubstr("UNDOCUMENTED RMR_ERR"));
  67 }
  68
  69 auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t));
  70
  71 TEST(sctp, TEST2) {
  72     struct epoll_event event;
  73     event.events = EPOLLIN;
  74     event.data.fd = 0;
  75     ConnectedCU_t data1;
  76     ConnectedCU_t *data = &data1;
  77     event.data.ptr = (void *)data;
  78     sctp_params_t sctp_ut_params;
  79     sctp_params_t* sctp = &sctp_ut_params;
  80     ReportingMessages_t reporting_msg;
  81     RmrMessagesBuffer_t rmrmessagesbuffer;
  82     handleEinprogressMessages(event,reporting_msg,rmrmessagesbuffer,sctp);
  83 }
  84
  85 TEST(sctp, TEST3) {
  86     struct epoll_event event;
  87     event.events = EPOLLIN;
  88     event.data.fd = 0;
  89     ConnectedCU_t data1;
  90     ConnectedCU_t *data = &data1;
  91     event.data.ptr = (void *)data;
  92     sctp_params_t sctp_ut_params;
  93     sctp_params_t* sctp = &sctp_ut_params;
  94     Sctp_Map_t m1;
  95     sctp ->sctpMap =  &m1;
  96     ReportingMessages_t reporting_msg;
  97     RmrMessagesBuffer_t rmrmessagesbuffer;
  98     handlepoll_error(event,reporting_msg,rmrmessagesbuffer,sctp);
  99 }
 100
 101 TEST(sctp, TEST4) {
 102     ConnectedCU_t cu;
 103     ConnectedCU_t* connected_cu = &cu;
 104     Sctp_Map_t m1;
 105     Sctp_Map_t *m = &m1;
 106     cleanHashEntry(connected_cu,m);
 107 }
 108
 109 TEST(sctp, TEST5) {
 110     sctp_params_t sctp_ut_params;
 111     sctp_params_t* sctp = &sctp_ut_params;
 112     sctp->configFilePath.assign("/opt/e2/RIC-E2-TERMINATION/config/");
 113     sctp->configFileName.assign("config.conf");
 114     handleConfigChange(sctp);
 115 }
 116
 117 TEST(sctp, TEST6) {
 118     int epoll_fd = epoll_create1(0);
 119     ConnectedCU_t cu;
 120     ConnectedCU_t* peerinfo = &cu;
 121     Sctp_Map_t m1;
 122     Sctp_Map_t *m = &m1;
 123     modifyToEpoll(epoll_fd,peerinfo,2,m, (char*)"enodeb1",2);
 124 }
 125
 126
 127 /* TEST7 Begin: */
 128 void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) {
 129     message.peerInfo = peerInfo;
 130     message.peerInfo->sctpParams = &sctp_ut_params;
 131     snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
 132
 133     sctp_ut_params.myIP = "1.2.3.4";
 134     sctp_ut_params.rmrPort = 38000;
 135     snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
 136
 137     rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 138     rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 139     rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA ");
 140     rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA");
 141 }
 142
 143 void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
 144
 145     if( (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) &&
 146         (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]) ) {
 147         free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]);
 148         pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = NULL;
 149     }
 150     if(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) {
 151         free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array);
 152         pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = NULL;
 153     }
 154     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 0;
 155     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = 0;
 156
 157     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 158         free(rmrMessageBuffer.sendMessage->header);
 159         rmrMessageBuffer.sendMessage->header = NULL;
 160     }
 161     if(rmrMessageBuffer.sendMessage->payload) {
 162         free(rmrMessageBuffer.sendMessage->payload);
 163         rmrMessageBuffer.sendMessage->payload = NULL;
 164     }
 165     if(rmrMessageBuffer.sendMessage) {
 166         free(rmrMessageBuffer.sendMessage);
 167         rmrMessageBuffer.sendMessage = NULL;
 168     }
 169     if(rmrMessageBuffer.rmrCtx) {
 170         rmr_close(rmrMessageBuffer.rmrCtx);
 171         rmrMessageBuffer.rmrCtx = NULL;
 172     }
 173 }
 174
 175 void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu,
 176         Sctp_Map_t *sctpMap,
 177         ReportingMessages_t &message,
 178         RmrMessagesBuffer_t &rmrMessageBuffer,
 179         sctp_params_t &sctp_ut_params) {
 180
 181     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 182     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
 183     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate;
 184     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate;
 185
 186     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
 187     delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
 188 }
 189
 190 void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu,
 191         Sctp_Map_t *sctpMap,
 192         ReportingMessages_t &message,
 193         RmrMessagesBuffer_t &rmrMessageBuffer,
 194         sctp_params_t &sctp_ut_params) {
 195
 196     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 197     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
 198     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication;
 199     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication;
 200     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*));
 201     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 1;
 202     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs);
 203     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs));
 204     RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0];
 205     ie->id = ProtocolIE_ID_id_RICrequestID;
 206     ie->value.present = RICindication_IEs__value_PR_RICrequestID;
 207     ie->value.choice.RICrequestID.ricRequestorID = 12345;
 208     ie->value.choice.RICrequestID.ricInstanceID = 1;
 209
 210     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
 211     delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
 212 }
 213
 214 void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu,
 215         Sctp_Map_t *sctpMap,
 216         ReportingMessages_t &message,
 217         RmrMessagesBuffer_t &rmrMessageBuffer,
 218         sctp_params_t &sctp_ut_params) {
 219
 220     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 221     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
 222     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication;
 223     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication;
 224     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
 225     delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
 226 }
 227
 228 void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu,
 229         Sctp_Map_t *sctpMap,
 230         ReportingMessages_t &message,
 231         RmrMessagesBuffer_t &rmrMessageBuffer,
 232         sctp_params_t &sctp_ut_params) {
 233
 234     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 235     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
 236     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 237     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest;
 238     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
 239     delete_memories_initiatingMessage(pdu, rmrMessageBuffer);
 240 }
 241
 242 TEST(sctp, TEST7) {
 243     E2AP_PDU_t              pdu;
 244     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 245     ReportingMessages_t     message;
 246     RmrMessagesBuffer_t     rmrMessageBuffer;
 247     sctp_params_t           sctp_ut_params;
 248
 249     pdu.present = E2AP_PDU_PR_initiatingMessage;
 250     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
 251     memset( (void*)pdu.choice.initiatingMessage, 0, sizeof(pdu.choice.initiatingMessage));
 252     memset( (void*)&message, 0, sizeof(message));
 253     memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
 254
 255     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
 256     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
 257
 258     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
 259     create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 260     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
 261     create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 262     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
 263     create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 264     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
 265     create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 266     /* For Procedure's Default case. */
 267     pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100);
 268     asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer);
 269
 270     if(pdu.choice.initiatingMessage) {
 271         free(pdu.choice.initiatingMessage);
 272         pdu.choice.initiatingMessage = NULL;
 273     }
 274     if(sctpMap) {
 275         delete sctpMap;
 276         sctpMap = NULL;
 277     }
 278 }
 279
 280 /* TEST8 Begin: */
 281 void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
 282
 283     if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) &&
 284         (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]) ) {
 285         free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]);
 286         pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = NULL;
 287     }
 288     if(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) {
 289         free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array);
 290         pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = NULL;
 291     }
 292     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 0;
 293     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = 0;
 294
 295     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 296         free(rmrMessageBuffer.sendMessage->header);
 297         rmrMessageBuffer.sendMessage->header = NULL;
 298     }
 299     if(rmrMessageBuffer.sendMessage->payload) {
 300         free(rmrMessageBuffer.sendMessage->payload);
 301         rmrMessageBuffer.sendMessage->payload = NULL;
 302     }
 303 #if 0
 304     if(rmrMessageBuffer.rmrCtx) {
 305         rmr_close(rmrMessageBuffer.rmrCtx);
 306         rmrMessageBuffer.rmrCtx = NULL;
 307     }
 308 #endif
 309     if(rmrMessageBuffer.sendMessage) {
 310         free(rmrMessageBuffer.sendMessage);
 311         rmrMessageBuffer.sendMessage = NULL;
 312     }
 313 }
 314
 315
 316 void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu,
 317         Sctp_Map_t *sctpMap,
 318         ReportingMessages_t &message,
 319         RmrMessagesBuffer_t &rmrMessageBuffer,
 320         sctp_params_t &sctp_ut_params) {
 321
 322     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 323     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
 324     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
 325     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 326     delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 327 }
 328
 329 void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
 330         Sctp_Map_t *sctpMap,
 331         ReportingMessages_t &message,
 332         RmrMessagesBuffer_t &rmrMessageBuffer,
 333         sctp_params_t &sctp_ut_params) {
 334
 335     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 336
 337     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*));
 338     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 1;
 339     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t);
 340     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t));
 341     RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0];
 342
 343     ie->id = ProtocolIE_ID_id_RICrequestID;
 344     ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID;
 345     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 346     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
 347     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 348     delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 349 }
 350
 351 void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
 352         Sctp_Map_t *sctpMap,
 353         ReportingMessages_t &message,
 354         RmrMessagesBuffer_t &rmrMessageBuffer,
 355         sctp_params_t &sctp_ut_params) {
 356
 357     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 358     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 359     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
 360     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 361     delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 362 }
 363
 364 void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
 365         Sctp_Map_t *sctpMap,
 366         ReportingMessages_t &message,
 367         RmrMessagesBuffer_t &rmrMessageBuffer,
 368         sctp_params_t &sctp_ut_params) {
 369
 370     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 371     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 372     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 373     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 374     delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 375 }
 376
 377 TEST(sctp, TEST8) {
 378     E2AP_PDU_t              pdu;
 379     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 380     ReportingMessages_t     message;
 381     RmrMessagesBuffer_t     rmrMessageBuffer;
 382     sctp_params_t           sctp_ut_params;
 383
 384     pdu.present = E2AP_PDU_PR_successfulOutcome;
 385     pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
 386     memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome));
 387     memset( (void*)&message, 0, sizeof(message));
 388     memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
 389
 390     snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
 391
 392     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
 393     create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 394     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 395     create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 396     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 397     create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 398     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 399     create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 400     /* For Procedure's Default case. */
 401     pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100);
 402     asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
 403
 404     if(pdu.choice.successfulOutcome) {
 405         free(pdu.choice.successfulOutcome);
 406         pdu.choice.successfulOutcome = NULL;
 407     }
 408     if(sctpMap) {
 409         delete sctpMap;
 410         sctpMap = NULL;
 411     }
 412 }
 413
 414 /* TEST9 Begin: */
 415 void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
 416
 417     if( (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) &&
 418         (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]) ) {
 419         free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]);
 420         pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = NULL;
 421     }
 422     if(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) {
 423         free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array);
 424         pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = NULL;
 425     }
 426     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 0;
 427     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = 0;
 428
 429     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 430         free(rmrMessageBuffer.sendMessage->header);
 431         rmrMessageBuffer.sendMessage->header = NULL;
 432     }
 433     if(rmrMessageBuffer.sendMessage->payload) {
 434         free(rmrMessageBuffer.sendMessage->payload);
 435         rmrMessageBuffer.sendMessage->payload = NULL;
 436     }
 437 #if 0
 438     if(rmrMessageBuffer.rmrCtx) {
 439         rmr_close(rmrMessageBuffer.rmrCtx);
 440         rmrMessageBuffer.rmrCtx = NULL;
 441     }
 442 #endif
 443     if(rmrMessageBuffer.sendMessage) {
 444         free(rmrMessageBuffer.sendMessage);
 445         rmrMessageBuffer.sendMessage = NULL;
 446     }
 447 }
 448
 449 void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
 450         Sctp_Map_t *sctpMap,
 451         ReportingMessages_t &message,
 452         RmrMessagesBuffer_t &rmrMessageBuffer,
 453         sctp_params_t &sctp_ut_params) {
 454
 455     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 456
 457     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*));
 458     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 1;
 459     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t);
 460     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t));
 461     RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0];
 462
 463     ie->id = ProtocolIE_ID_id_RICrequestID;
 464     ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID;
 465     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 466     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
 467     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 468     delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 469 }
 470
 471 void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
 472         Sctp_Map_t *sctpMap,
 473         ReportingMessages_t &message,
 474         RmrMessagesBuffer_t &rmrMessageBuffer,
 475         sctp_params_t &sctp_ut_params) {
 476
 477     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 478     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 479     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
 480     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 481     delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 482 }
 483
 484 void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
 485         Sctp_Map_t *sctpMap,
 486         ReportingMessages_t &message,
 487         RmrMessagesBuffer_t &rmrMessageBuffer,
 488         sctp_params_t &sctp_ut_params) {
 489
 490     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 491     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 492     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 493     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 494     delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 495 }
 496
 497 TEST(sctp, TEST9) {
 498     E2AP_PDU_t              pdu;
 499     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 500     ReportingMessages_t     message;
 501     RmrMessagesBuffer_t     rmrMessageBuffer;
 502     sctp_params_t           sctp_ut_params;
 503
 504     pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
 505     pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
 506     memset( (void*)pdu.choice.unsuccessfulOutcome, 0, sizeof(pdu.choice.unsuccessfulOutcome));
 507     memset( (void*)&message, 0, sizeof(message));
 508     memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
 509
 510     snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
 511
 512     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 513     create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 514     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 515     create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 516     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 517     create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 518     /* For Procedure's Default case. */
 519     pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100);
 520     asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
 521
 522     if(pdu.choice.unsuccessfulOutcome) {
 523         free(pdu.choice.unsuccessfulOutcome);
 524         pdu.choice.unsuccessfulOutcome = NULL;
 525     }
 526     if(sctpMap) {
 527         delete sctpMap;
 528         sctpMap = NULL;
 529     }
 530 }
 531
 532
 533 TEST(sctp, TEST10) {
 534     int epoll_fd = epoll_create1(0);
 535     ConnectedCU_t cu;
 536     ConnectedCU_t* peerinfo = &cu;
 537     Sctp_Map_t m1;
 538     Sctp_Map_t *m = &m1;
 539     addToEpoll(epoll_fd, peerinfo, 2, m, (char*)"enodeb1", 0);
 540 }
 541
 542 TEST(sctp, TEST11) {
 543     sctp_params_t sctpParams;
 544     int argc = 5;
 545     char **argv = (char**) calloc(argc, sizeof(char*));
 546     argv[0] = (char*) malloc(40 * sizeof(char));
 547     argv[1] = (char*) malloc(40 * sizeof(char));
 548     argv[2] = (char*) malloc(40 * sizeof(char));
 549     argv[3] = (char*) malloc(40 * sizeof(char));
 550     argv[4] = (char*) malloc(40 * sizeof(char));
 551     snprintf(argv[0], strlen("./e2 "), "%s", (char*)"./e2");
 552     snprintf(argv[1], strlen("-p "), "%s", (char*)"-p");
 553     snprintf(argv[2], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config");
 554     snprintf(argv[3], strlen("-f "), "%s", (char*)"-f");
 555     snprintf(argv[4], strlen("config.conf "), "%s", (char*)"config.conf");
 556
 557     auto result = parse(argc, argv, sctpParams);
 558     sctpParams.podName.assign("E2TermAlpha_pod");
 559     sctpParams.sctpMap = new mapWrapper();
 560     sctpParams.epoll_fd = epoll_create1(0);
 561     buildConfiguration(sctpParams);
 562     // getRmrContext(sctpParams);
 563     buildInotify(sctpParams);
 564     buildListeningPort(sctpParams);
 565     listener(&sctpParams);
 566
 567     if(sctpParams.sctpMap) {
 568         delete sctpParams.sctpMap;
 569         sctpParams.sctpMap = NULL;
 570     }
 571     if(argv) {
 572         free(argv[0]);
 573         argv[0] = NULL;
 574         free(argv[1]);
 575         argv[1] = NULL;
 576         free(argv[2]);
 577         argv[2] = NULL;
 578         free(argv[3]);
 579         argv[3] = NULL;
 580         free(argv[4]);
 581         argv[4] = NULL;
 582         free(argv);
 583         argv=NULL;
 584     }
 585 }
 586
 587 TEST(sctp, TEST12) {
 588     ReportingMessages_t     reporting_msg;
 589     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 590     sendSctpMsg(peerInfo, reporting_msg, sctpMap);
 591
 592     if(sctpMap) {
 593         delete sctpMap;
 594         sctpMap = NULL;
 595     }
 596 }
 597
 598 /*TEST13 Begin*/
 599
 600 void inti_buffers_rcv(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 601     message.peerInfo = peerInfo;
 602     snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
 603
 604     rmrMessageBuffer.rcvMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 605     rmrMessageBuffer.rcvMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 606     rmrMessageBuffer.rcvMessage->len = strlen("Saying Hello from Ramji ");
 607     rmrMessageBuffer.rcvMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
 608
 609     rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 610     rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 611     rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji ");
 612     rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
 613
 614 }
 615
 616 void delete_memories_rcv(RmrMessagesBuffer_t &rmrMessageBuffer) {
 617
 618     if(rmrMessageBuffer.rcvMessage && rmrMessageBuffer.rcvMessage->header) {
 619         free(rmrMessageBuffer.rcvMessage->header);
 620         rmrMessageBuffer.rcvMessage->header = NULL;
 621     }
 622     if(rmrMessageBuffer.rcvMessage) {
 623         free(rmrMessageBuffer.rcvMessage);
 624         rmrMessageBuffer.rcvMessage = NULL;
 625     }
 626     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 627         free(rmrMessageBuffer.sendMessage->header);
 628         rmrMessageBuffer.sendMessage->header = NULL;
 629     }
 630     if(rmrMessageBuffer.sendMessage) {
 631         free(rmrMessageBuffer.sendMessage);
 632         rmrMessageBuffer.sendMessage = NULL;
 633     }
 634
 635 }
 636
 637 void create_receiveXappMessages_RIC_ERROR_INDICATION(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 638         RmrMessagesBuffer_t &rmrMessageBuffer) {
 639     inti_buffers_rcv(message, rmrMessageBuffer);
 640     rmrMessageBuffer.rcvMessage->mtype = RIC_ERROR_INDICATION;
 641     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 642     delete_memories_rcv(rmrMessageBuffer);
 643
 644 }
 645 void create_receiveXappMessages_RIC_E2_SETUP_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 646         RmrMessagesBuffer_t &rmrMessageBuffer) {
 647     inti_buffers_rcv(message, rmrMessageBuffer);
 648     rmrMessageBuffer.rcvMessage->mtype = RIC_E2_SETUP_FAILURE;
 649     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 650     delete_memories_rcv(rmrMessageBuffer);
 651 }
 652
 653 void create_receiveXappMessages_RIC_SUB_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 654         RmrMessagesBuffer_t &rmrMessageBuffer) {
 655     inti_buffers_rcv(message, rmrMessageBuffer);
 656     rmrMessageBuffer.rcvMessage->mtype = RIC_SUB_REQ;
 657     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 658     delete_memories_rcv(rmrMessageBuffer);
 659 }
 660
 661 void create_receiveXappMessages_RIC_CONTROL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 662         RmrMessagesBuffer_t &rmrMessageBuffer) {
 663     inti_buffers_rcv(message, rmrMessageBuffer);
 664     rmrMessageBuffer.rcvMessage->mtype = RIC_CONTROL_REQ;
 665     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 666     delete_memories_rcv(rmrMessageBuffer);
 667 }
 668
 669 void create_receiveXappMessages_RIC_SERVICE_QUERY(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 670         RmrMessagesBuffer_t &rmrMessageBuffer) {
 671     inti_buffers_rcv(message, rmrMessageBuffer);
 672     rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_QUERY;
 673     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 674     delete_memories_rcv(rmrMessageBuffer);
 675 }
 676
 677 void create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 678         RmrMessagesBuffer_t &rmrMessageBuffer) {
 679     inti_buffers_rcv(message, rmrMessageBuffer);
 680     rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_ACK;
 681     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 682     delete_memories_rcv(rmrMessageBuffer);
 683 }
 684
 685 void create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 686         RmrMessagesBuffer_t &rmrMessageBuffer) {
 687     inti_buffers_rcv(message, rmrMessageBuffer);
 688     rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_FAILURE;
 689     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 690     delete_memories_rcv(rmrMessageBuffer);
 691 }
 692
 693
 694 void create_receiveXappMessages_RIC_E2_RESET_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 695         RmrMessagesBuffer_t &rmrMessageBuffer) {
 696     inti_buffers_rcv(message, rmrMessageBuffer);
 697     rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_REQ;
 698     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 699     delete_memories_rcv(rmrMessageBuffer);
 700 }
 701
 702 void create_receiveXappMessages_RIC_E2_RESET_RESP(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 703         RmrMessagesBuffer_t &rmrMessageBuffer) {
 704     inti_buffers_rcv(message, rmrMessageBuffer);
 705     rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_RESP;
 706     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 707     delete_memories_rcv(rmrMessageBuffer);
 708 }
 709
 710 void create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 711         RmrMessagesBuffer_t &rmrMessageBuffer) {
 712     inti_buffers_rcv(message, rmrMessageBuffer);
 713     rmrMessageBuffer.rcvMessage->mtype = RIC_SCTP_CLEAR_ALL;
 714     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 715     delete_memories_rcv(rmrMessageBuffer);
 716 }
 717
 718 void create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 719         RmrMessagesBuffer_t &rmrMessageBuffer) {
 720     inti_buffers_rcv(message, rmrMessageBuffer);
 721     rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_REQ;
 722     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 723     delete_memories_rcv(rmrMessageBuffer);
 724 }
 725
 726 void create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 727         RmrMessagesBuffer_t &rmrMessageBuffer) {
 728     inti_buffers_rcv(message, rmrMessageBuffer);
 729     rmrMessageBuffer.rcvMessage->mtype = E2_TERM_KEEP_ALIVE_REQ;
 730     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 731     delete_memories_rcv(rmrMessageBuffer);
 732 }
 733
 734
 735 TEST(sctp, TEST13) {
 736     Sctp_Map_t *sctpMap = new Sctp_Map_t();
 737     ReportingMessages_t message;
 738     RmrMessagesBuffer_t rmrMessageBuffer;
 739
 740     memset( (void*)&message, 0, sizeof(message));
 741     memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
 742
 743     // Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset
 744     create_receiveXappMessages_RIC_E2_SETUP_FAILURE(sctpMap, message, rmrMessageBuffer);
 745     create_receiveXappMessages_RIC_ERROR_INDICATION(sctpMap, message, rmrMessageBuffer);
 746     create_receiveXappMessages_RIC_SUB_REQ(sctpMap, message, rmrMessageBuffer);
 747     create_receiveXappMessages_RIC_CONTROL_REQ(sctpMap, message, rmrMessageBuffer);
 748     create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(sctpMap, message, rmrMessageBuffer);
 749     create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(sctpMap, message, rmrMessageBuffer);
 750     create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
 751     create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
 752     create_receiveXappMessages_RIC_E2_RESET_RESP(sctpMap, message, rmrMessageBuffer);
 753     create_receiveXappMessages_RIC_E2_RESET_REQ(sctpMap, message, rmrMessageBuffer);
 754     create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer);
 755     create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(sctpMap, message, rmrMessageBuffer);
 756     create_receiveXappMessages_RIC_SERVICE_QUERY(sctpMap, message, rmrMessageBuffer);
 757
 758     inti_buffers_rcv(message, rmrMessageBuffer);
 759     rmrMessageBuffer.rcvMessage->mtype = 100;
 760     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 761     delete_memories_rcv(rmrMessageBuffer);
 762
 763     if(sctpMap) {
 764         delete sctpMap;
 765         sctpMap = NULL;
 766     }
 767 }
 768
 769 int main(int argc, char **argv) {
 770
 771    testing::InitGoogleTest(&argc, argv);
 772    return RUN_ALL_TESTS();
 773
 774 }