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 constexpr int numberSix = 6;
  29 constexpr int numberSeven = 7;
  30 constexpr int numberEight = 8;
  31 constexpr int numberNine = 9;
  32 constexpr int numberTen = 10;
  33 constexpr int numberEleven = 11;
  34 constexpr int numberTwelve = 12;
  35 constexpr int numberThirteen = 13;
  36 constexpr int numberFourteen = 14;
  37 constexpr int numberFifteen = 15;
  38 constexpr int numberSixteen = 16;
  39 constexpr int numberSeventeen = 17;
  40 constexpr int numberForty = 40;
  41 constexpr int numberHundred = 100;
  42 constexpr int rmrPort = 38000;
  43 constexpr auto dummyIp = "1.2.3.4";
  44 constexpr int ricRequestorId = 12345;
  45
  46 extern std::map<std::string, E2NodeConnectionHandling> connectionHandlingPerE2NodeMap;
  47
  48 void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params);
  49 void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer,bool IsRICIndication, bool IsE2SetupReq, bool IsErrorIndication);
  50 void setE2SetupProcedureNotInitiatedToMap(char *enodbName);
  51 void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer);
  52 void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer);
  53 void resetToDefaultValueAsTeardown(char *enodbName)
  54 {
  55     setE2SetupProcedureNotInitiatedToMap(enodbName);
  56 }
  57
  58 TEST(sctp, TEST1) {
  59     mdclog_level_set(MDCLOG_DEBUG);
  60     string s;
  61     s = translateRmrErrorMessages(numberZero);
  62     EXPECT_THAT(s, HasSubstr("RMR_OK"));
  63     s = translateRmrErrorMessages(numberOne);
  64     EXPECT_THAT(s, HasSubstr("RMR_ERR_BADARG"));
  65     s = translateRmrErrorMessages(numberTwo);
  66     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOENDPT"));
  67     s = translateRmrErrorMessages(numberThree);
  68     EXPECT_THAT(s, HasSubstr("RMR_ERR_EMPTY"));
  69     s = translateRmrErrorMessages(numberFour);
  70     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOHDR"));
  71     s = translateRmrErrorMessages(numberFive);
  72     EXPECT_THAT(s, HasSubstr("RMR_ERR_SENDFAILED"));
  73     s = translateRmrErrorMessages(numberSix);
  74     EXPECT_THAT(s, HasSubstr("RMR_ERR_CALLFAILED"));
  75     s = translateRmrErrorMessages(numberSeven);
  76     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOWHOPEN"));
  77     s = translateRmrErrorMessages(numberEight);
  78     EXPECT_THAT(s, HasSubstr("RMR_ERR_WHID"));
  79     s = translateRmrErrorMessages(numberNine);
  80     EXPECT_THAT(s, HasSubstr("RMR_ERR_OVERFLOW"));
  81     s = translateRmrErrorMessages(numberTen);
  82     EXPECT_THAT(s, HasSubstr("RMR_ERR_RETRY"));
  83     s = translateRmrErrorMessages(numberEleven);
  84     EXPECT_THAT(s, HasSubstr("RMR_ERR_RCVFAILED"));
  85     s = translateRmrErrorMessages(numberTwelve);
  86     EXPECT_THAT(s, HasSubstr("RMR_ERR_TIMEOUT"));
  87     s = translateRmrErrorMessages(numberThirteen);
  88     EXPECT_THAT(s, HasSubstr("RMR_ERR_UNSET"));
  89     s = translateRmrErrorMessages(numberFourteen);
  90     EXPECT_THAT(s, HasSubstr("RMR_ERR_TRUNC"));
  91     s = translateRmrErrorMessages(numberFifteen);
  92     EXPECT_THAT(s, HasSubstr("RMR_ERR_INITFAILED"));
  93     s = translateRmrErrorMessages(numberSixteen);
  94     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOTSUPP"));
  95     s = translateRmrErrorMessages(numberSeventeen);
  96     EXPECT_THAT(s, HasSubstr("UNDOCUMENTED RMR_ERR"));
  97 }
  98
  99 auto *peerInfo = (ConnectedCU_t *)calloc(numberOne, sizeof(ConnectedCU_t));
 100
 101 TEST(sctp, TEST2) {
 102     struct epoll_event event;
 103     event.events = EPOLLIN;
 104     event.data.fd = numberZero;
 105     ConnectedCU_t data1;
 106     ConnectedCU_t *data = &data1;
 107     event.data.ptr = (void *)data;
 108     sctp_params_t sctp_ut_params;
 109     sctp_params_t* sctp = &sctp_ut_params;
 110     ReportingMessages_t reporting_msg;
 111     RmrMessagesBuffer_t rmrmessagesbuffer;
 112     handleEinprogressMessages(event,reporting_msg,rmrmessagesbuffer,sctp);
 113 }
 114
 115 TEST(sctp, TestSctpAbortThenE2tShouldNotCrash) {
 116     struct epoll_event event;
 117     event.events = EPOLLIN;
 118     event.data.fd = numberZero;
 119     ConnectedCU_t data1;
 120     ConnectedCU_t *data = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
 121     event.data.ptr = (void *)data;
 122     sctp_params_t sctp_ut_params;
 123     sctp_params_t* sctp = &sctp_ut_params;
 124     Sctp_Map_t m1;
 125     sctp ->sctpMap =  &m1;
 126     ReportingMessages_t reporting_msg;
 127     RmrMessagesBuffer_t rmrmessagesbuffer;
 128     handlepoll_error(event,reporting_msg,rmrmessagesbuffer,sctp);
 129 }
 130
 131 TEST(sctp, TEST4) {
 132     ConnectedCU_t cu;
 133     ConnectedCU_t* connected_cu1 = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
 134     Sctp_Map_t m1;
 135     Sctp_Map_t *m = &m1;
 136     cleanHashEntry(connected_cu1,m);
 137 }
 138
 139 TEST(sctp, TEST5) {
 140     sctp_params_t sctp_ut_params;
 141     sctp_params_t* sctp = &sctp_ut_params;
 142     sctp->configFilePath.assign("/opt/e2/RIC-E2-TERMINATION/config");
 143     sctp->configFileName.assign("config.conf");
 144     handleConfigChange(sctp);
 145 }
 146
 147 TEST(sctp, TEST6) {
 148     int epoll_fd = epoll_create1(numberZero);
 149     ConnectedCU_t cu;
 150     ConnectedCU_t* peerinfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
 151     Sctp_Map_t m1;
 152     Sctp_Map_t *m = &m1;
 153     modifyToEpoll(epoll_fd,peerinfo,numberTwo,m, (char*)"enodeb1",numberTwo);
 154 }
 155
 156 TEST(sctp, TEST17) {
 157     sctp_params_t sctpParams;
 158     sctpParams.inotifyFD = negativeOne;
 159     buildInotify(sctpParams);
 160 }
 161
 162 TEST(sctp, TEST18) {
 163     sctp_params_t sctpParams;
 164     sctpParams.inotifyWD = negativeOne;
 165     buildInotify(sctpParams);
 166 }
 167
 168
 169 /* TEST7 Begin: */
 170 void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) {
 171     message.peerInfo = peerInfo;
 172     message.peerInfo->sctpParams = &sctp_ut_params;
 173     snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
 174
 175     sctp_ut_params.myIP = dummyIp;
 176     sctp_ut_params.rmrPort = rmrPort;
 177     snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
 178
 179     rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 180     rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 181     rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA ");
 182     rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA");
 183 }
 184
 185 void deleteMemoryForE2SetupReq(E2AP_PDU_t *pdu)
 186 {
 187     if( (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) &&
 188         (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]) ) {
 189         free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]);
 190         pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = NULL;
 191     }
 192     if( (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) &&
 193         (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]) ) {
 194         free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]);
 195         pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne] = NULL;
 196     }
 197     if(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) {
 198         free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array);
 199         pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = NULL;
 200     }
 201
 202     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = numberZero;
 203     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = numberZero;
 204 }
 205
 206 void deleteMemoryForRicIndication(E2AP_PDU_t *pdu)
 207 {
 208     if( (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) &&
 209         (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]) ) {
 210         free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]);
 211         pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero] = NULL;
 212     }
 213     if(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) {
 214         free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array);
 215         pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = NULL;
 216     }
 217     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = numberZero;
 218     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = numberZero;
 219 }
 220
 221 void deleteMemoryForErrorIndication(E2AP_PDU_t *pdu)
 222 {
 223     if( (pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array) &&
 224         (pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]) ) {
 225         free(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]);
 226         pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero] = NULL;
 227     }
 228     if(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array) {
 229         free(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array);
 230         pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array = NULL;
 231     }
 232     pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count = numberZero;
 233     pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.size = numberZero;
 234 }
 235
 236 void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer,bool IsRICIndication, bool IsE2SetupReq, bool IsErrorIndication) {
 237     if(IsE2SetupReq){
 238         deleteMemoryForE2SetupReq(pdu);
 239     }
 240     if(IsRICIndication){
 241         deleteMemoryForRicIndication(pdu);
 242     }
 243     if(IsErrorIndication){
 244         deleteMemoryForErrorIndication(pdu);
 245     }
 246     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 247         free(rmrMessageBuffer.sendMessage->header);
 248         rmrMessageBuffer.sendMessage->header = NULL;
 249     }
 250     if(rmrMessageBuffer.sendMessage->payload) {
 251         free(rmrMessageBuffer.sendMessage->payload);
 252         rmrMessageBuffer.sendMessage->payload = NULL;
 253     }
 254     if(rmrMessageBuffer.sendMessage) {
 255         free(rmrMessageBuffer.sendMessage);
 256         rmrMessageBuffer.sendMessage = NULL;
 257     }
 258     if(rmrMessageBuffer.rmrCtx) {
 259         rmr_close(rmrMessageBuffer.rmrCtx);
 260         rmrMessageBuffer.rmrCtx = NULL;
 261     }
 262 }
 263
 264 void create_asnInitiatingReq_Procedure_E2Setup(E2AP_PDU_t *pdu,
 265         Sctp_Map_t *sctpMap,
 266         ReportingMessages_t &message,
 267         RmrMessagesBuffer_t &rmrMessageBuffer,
 268         sctp_params_t &sctp_ut_params) {
 269
 270     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 271     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2setup */
 272     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_E2setup;
 273     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest;
 274
 275     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = (E2setupRequestIEs**) malloc(1 * sizeof(E2setupRequestIEs*));
 276     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = 2;
 277     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = sizeof(E2setupRequestIEs);
 278     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs));
 279     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs));
 280     E2setupRequestIEs_t *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero];
 281     ie->id = ProtocolIE_ID_id_GlobalE2node_ID;
 282     ie->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
 283     ie->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
 284
 285     ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne];
 286     ie->id = ProtocolIE_ID_id_TransactionID;
 287     ie->value.present = E2setupRequestIEs__value_PR_TransactionID;
 288     ie->value.choice.TransactionID = numberOne;
 289
 290     int streamId = numberZero;
 291
 292     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
 293     delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, true, false);
 294 }
 295
 296 void unsupportedRicSubscriptionDelReq(E2AP_PDU_t *pdu,
 297         Sctp_Map_t *sctpMap,
 298         ReportingMessages_t &message,
 299         RmrMessagesBuffer_t &rmrMessageBuffer,
 300         sctp_params_t &sctp_ut_params) {
 301
 302     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 303     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICsubscriptionDeleteRequired */
 304     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICsubscriptionDeleteRequired;
 305     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequired;
 306
 307     int streamId = numberZero;
 308
 309     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
 310     delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false);
 311 }
 312
 313 void unsupportedE2ConnectionUpdateAck(E2AP_PDU_t *pdu,
 314         Sctp_Map_t *sctpMap,
 315         ReportingMessages_t &message,
 316         RmrMessagesBuffer_t &rmrMessageBuffer,
 317         sctp_params_t &sctp_ut_params) {
 318
 319     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 320     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2connectionUpdate */
 321     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_E2connectionUpdate;
 322     pdu->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_E2connectionUpdateAcknowledge;
 323
 324     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 325     // delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 326 }
 327
 328 void deleteMemoriesForUnsupportedE2ConnectionUpdate(RmrMessagesBuffer_t &rmrMessageBuffer)
 329 {
 330     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 331         free(rmrMessageBuffer.sendMessage->header);
 332         rmrMessageBuffer.sendMessage->header = NULL;
 333     }
 334     if(rmrMessageBuffer.sendMessage->payload) {
 335         free(rmrMessageBuffer.sendMessage->payload);
 336         rmrMessageBuffer.sendMessage->payload = NULL;
 337     }
 338     if(rmrMessageBuffer.sendMessage) {
 339         free(rmrMessageBuffer.sendMessage);
 340         rmrMessageBuffer.sendMessage = NULL;
 341     }
 342 }
 343
 344 void unsupportedE2ConnectionUpdateFail(E2AP_PDU_t *pdu,
 345         Sctp_Map_t *sctpMap,
 346         ReportingMessages_t &message,
 347         RmrMessagesBuffer_t &rmrMessageBuffer,
 348         sctp_params_t &sctp_ut_params) {
 349
 350     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 351     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2connectionUpdate */
 352     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_E2connectionUpdate;
 353     pdu->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcome__value_PR_E2nodeConfigurationUpdateFailure;
 354
 355     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 356
 357     deleteMemoriesForUnsupportedE2ConnectionUpdate(rmrMessageBuffer);
 358 }
 359
 360 void create_asnInitiatingReq_Procedure_E2SetupWithoutTransactionID(E2AP_PDU_t *pdu,
 361         Sctp_Map_t *sctpMap,
 362         ReportingMessages_t &message,
 363         RmrMessagesBuffer_t &rmrMessageBuffer,
 364         sctp_params_t &sctp_ut_params) {
 365
 366     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 367     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2setup */
 368     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_E2setup;
 369     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest;
 370
 371     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = (E2setupRequestIEs**) malloc(1 * sizeof(E2setupRequestIEs*));
 372     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = numberOne;
 373     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = sizeof(E2setupRequestIEs);
 374     pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs));
 375     E2setupRequestIEs_t *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero];
 376     ie->id = ProtocolIE_ID_id_GlobalE2node_ID;
 377     ie->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
 378     ie->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
 379
 380     int streamId = numberZero;
 381
 382     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
 383     delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, true, false);
 384 }
 385
 386 void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu,
 387         Sctp_Map_t *sctpMap,
 388         ReportingMessages_t &message,
 389         RmrMessagesBuffer_t &rmrMessageBuffer,
 390         sctp_params_t &sctp_ut_params) {
 391
 392     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 393     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
 394     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate;
 395     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate;
 396
 397     int streamId = numberZero;
 398
 399     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
 400     delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false);
 401 }
 402
 403 void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu,
 404         Sctp_Map_t *sctpMap,
 405         ReportingMessages_t &message,
 406         RmrMessagesBuffer_t &rmrMessageBuffer,
 407         sctp_params_t &sctp_ut_params) {
 408
 409     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 410     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
 411     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication;
 412     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication;
 413     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*));
 414     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = numberOne;
 415     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs);
 416     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs));
 417     RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero];
 418     ie->id = ProtocolIE_ID_id_RICrequestID;
 419     ie->value.present = RICindication_IEs__value_PR_RICrequestID;
 420     ie->value.choice.RICrequestID.ricRequestorID = ricRequestorId;
 421     ie->value.choice.RICrequestID.ricInstanceID = numberOne;
 422     int streamId = numberZero;
 423
 424     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
 425     delete_memories_initiatingMessage(pdu, rmrMessageBuffer,true, false, false);
 426 }
 427
 428 void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu,
 429         Sctp_Map_t *sctpMap,
 430         ReportingMessages_t &message,
 431         RmrMessagesBuffer_t &rmrMessageBuffer,
 432         sctp_params_t &sctp_ut_params) {
 433
 434     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 435     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
 436     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication;
 437     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication;
 438     int streamId = numberZero;
 439
 440     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer, streamId);
 441     delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false);
 442 }
 443
 444 void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu,
 445         Sctp_Map_t *sctpMap,
 446         ReportingMessages_t &message,
 447         RmrMessagesBuffer_t &rmrMessageBuffer,
 448         sctp_params_t &sctp_ut_params) {
 449
 450     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 451     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
 452     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 453     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest;
 454     int streamId =numberZero;
 455
 456     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
 457     delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false);
 458 }
 459
 460 void setE2SetupProcedureNotInitiatedToMap(char *enbName)
 461 {
 462     printEntryPresentInMap();
 463     if(connectionHandlingPerE2NodeMap.empty())
 464     {
 465         mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty");
 466         return;
 467     }
 468     else
 469     {
 470         mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map");
 471         std::map<std::string, E2NodeConnectionHandling>::iterator itr = connectionHandlingPerE2NodeMap.begin();
 472         while(itr != connectionHandlingPerE2NodeMap.end())
 473         {
 474             mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus);
 475             int result = itr->first.compare(enbName);
 476             if (result == 0)
 477             {
 478                 mdclog_write(MDCLOG_DEBUG, "Updating to E2SetupOngoing Procedure");
 479                 itr->second.e2tProcedureOngoingStatus = E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED;
 480                 mdclog_write(MDCLOG_DEBUG, "Current procedure updated to %d", itr->second.e2tProcedureOngoingStatus);
 481                 itr->second.e2SetupProcedureTransactionId = negativeOne;
 482                 break;
 483             }
 484             ++itr;
 485         }
 486     }
 487 }
 488 TEST(sctp, TESTBeforeE2SetupReqThenDropTheMessage) {
 489     E2AP_PDU_t              pdu;
 490     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 491     ReportingMessages_t     message;
 492     RmrMessagesBuffer_t     rmrMessageBuffer;
 493     sctp_params_t           sctp_ut_params;
 494     struct E2NodeConnectionHandling e2NodeConnectionHandling;
 495     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
 496     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
 497     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
 498
 499     pdu.present = E2AP_PDU_PR_initiatingMessage;
 500     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
 501     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
 502     memset( (void*)&message, numberZero, sizeof(message));
 503     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
 504
 505     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
 506     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
 507
 508     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
 509     create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 510     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
 511     create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 512     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
 513     create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 514     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
 515     create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 516     /* For Procedure's Default case. */
 517     pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100);
 518     int streamId =numberZero;
 519
 520     asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer,streamId);
 521
 522     if(pdu.choice.initiatingMessage) {
 523         free(pdu.choice.initiatingMessage);
 524         pdu.choice.initiatingMessage = NULL;
 525     }
 526     if(sctpMap) {
 527         delete sctpMap;
 528         sctpMap = NULL;
 529     }
 530     resetToDefaultValueAsTeardown(message.message.enodbName);
 531     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
 532 }
 533
 534 /* TEST8 Begin: */
 535 void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
 536
 537     if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) &&
 538         (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]) ) {
 539         free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]);
 540         pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero] = NULL;
 541     }
 542     if(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) {
 543         free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array);
 544         pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = NULL;
 545     }
 546     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = numberZero;
 547     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = numberZero;
 548
 549     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 550         free(rmrMessageBuffer.sendMessage->header);
 551         rmrMessageBuffer.sendMessage->header = NULL;
 552     }
 553     if(rmrMessageBuffer.sendMessage->payload) {
 554         free(rmrMessageBuffer.sendMessage->payload);
 555         rmrMessageBuffer.sendMessage->payload = NULL;
 556     }
 557     if(rmrMessageBuffer.sendMessage) {
 558         free(rmrMessageBuffer.sendMessage);
 559         rmrMessageBuffer.sendMessage = NULL;
 560     }
 561 }
 562
 563
 564 void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu,
 565         Sctp_Map_t *sctpMap,
 566         ReportingMessages_t &message,
 567         RmrMessagesBuffer_t &rmrMessageBuffer,
 568         sctp_params_t &sctp_ut_params) {
 569
 570     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 571     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
 572     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
 573     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 574     delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 575 }
 576
 577 void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
 578         Sctp_Map_t *sctpMap,
 579         ReportingMessages_t &message,
 580         RmrMessagesBuffer_t &rmrMessageBuffer,
 581         sctp_params_t &sctp_ut_params) {
 582
 583     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 584
 585     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*));
 586     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = numberOne;
 587     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t);
 588     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t));
 589     RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero];
 590
 591     ie->id = ProtocolIE_ID_id_RICrequestID;
 592     ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID;
 593     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 594     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
 595     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 596     delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 597 }
 598
 599 void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
 600         Sctp_Map_t *sctpMap,
 601         ReportingMessages_t &message,
 602         RmrMessagesBuffer_t &rmrMessageBuffer,
 603         sctp_params_t &sctp_ut_params) {
 604
 605     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 606     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 607     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
 608     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 609     delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 610 }
 611
 612 void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
 613         Sctp_Map_t *sctpMap,
 614         ReportingMessages_t &message,
 615         RmrMessagesBuffer_t &rmrMessageBuffer,
 616         sctp_params_t &sctp_ut_params) {
 617
 618     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 619     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 620     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 621     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 622     delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
 623 }
 624
 625 TEST(sctp, TEST8) {
 626     E2AP_PDU_t              pdu;
 627     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 628     ReportingMessages_t     message;
 629     RmrMessagesBuffer_t     rmrMessageBuffer;
 630     sctp_params_t           sctp_ut_params;
 631
 632     pdu.present = E2AP_PDU_PR_successfulOutcome;
 633     pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
 634     memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome));
 635     memset( (void*)&message, numberZero, sizeof(message));
 636     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
 637
 638     snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
 639
 640     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
 641     create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 642     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 643     create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 644     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 645     create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 646     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 647     create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 648     /* For Procedure's Default case. */
 649     pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)numberHundred);
 650     asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
 651
 652     if(pdu.choice.successfulOutcome) {
 653         free(pdu.choice.successfulOutcome);
 654         pdu.choice.successfulOutcome = NULL;
 655     }
 656     if(sctpMap) {
 657         delete sctpMap;
 658         sctpMap = NULL;
 659     }
 660 }
 661
 662 /* TEST9 Begin: */
 663 void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
 664
 665     if( (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) &&
 666         (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]) ) {
 667         free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]);
 668         pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero] = NULL;
 669     }
 670     if(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) {
 671         free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array);
 672         pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = NULL;
 673     }
 674     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = numberZero;
 675     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = numberZero;
 676
 677     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 678         free(rmrMessageBuffer.sendMessage->header);
 679         rmrMessageBuffer.sendMessage->header = NULL;
 680     }
 681     if(rmrMessageBuffer.sendMessage->payload) {
 682         free(rmrMessageBuffer.sendMessage->payload);
 683         rmrMessageBuffer.sendMessage->payload = NULL;
 684     }
 685     if(rmrMessageBuffer.sendMessage) {
 686         free(rmrMessageBuffer.sendMessage);
 687         rmrMessageBuffer.sendMessage = NULL;
 688     }
 689 }
 690
 691 void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
 692         Sctp_Map_t *sctpMap,
 693         ReportingMessages_t &message,
 694         RmrMessagesBuffer_t &rmrMessageBuffer,
 695         sctp_params_t &sctp_ut_params) {
 696
 697     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 698
 699     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*));
 700     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = numberOne;
 701     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t);
 702     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t));
 703     RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero];
 704
 705     ie->id = ProtocolIE_ID_id_RICrequestID;
 706     ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID;
 707     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 708     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
 709     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 710     delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 711 }
 712
 713 void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
 714         Sctp_Map_t *sctpMap,
 715         ReportingMessages_t &message,
 716         RmrMessagesBuffer_t &rmrMessageBuffer,
 717         sctp_params_t &sctp_ut_params) {
 718
 719     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 720     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 721     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
 722     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 723     delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 724 }
 725
 726 void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
 727         Sctp_Map_t *sctpMap,
 728         ReportingMessages_t &message,
 729         RmrMessagesBuffer_t &rmrMessageBuffer,
 730         sctp_params_t &sctp_ut_params) {
 731     init_memories(message, rmrMessageBuffer, sctp_ut_params);
 732     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 733     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 734     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 735     delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
 736 }
 737
 738 TEST(sctp, TEST9) {
 739     E2AP_PDU_t              pdu;
 740     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 741     ReportingMessages_t     message;
 742     RmrMessagesBuffer_t     rmrMessageBuffer;
 743     sctp_params_t           sctp_ut_params;
 744
 745     pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
 746     pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
 747     memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome));
 748     memset( (void*)&message, numberZero, sizeof(message));
 749     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
 750
 751     snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
 752
 753     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 754     create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 755     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 756     create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 757     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 758     create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
 759     /* For Procedure's Default case. */
 760     pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)numberHundred);
 761     asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
 762
 763     if(pdu.choice.unsuccessfulOutcome) {
 764         free(pdu.choice.unsuccessfulOutcome);
 765         pdu.choice.unsuccessfulOutcome = NULL;
 766     }
 767     if(sctpMap) {
 768         delete sctpMap;
 769         sctpMap = NULL;
 770     }
 771 }
 772
 773
 774 TEST(sctp, TEST10) {
 775     int epoll_fd = epoll_create1(numberZero);
 776     ConnectedCU_t cu;
 777     ConnectedCU_t* peerinfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
 778     Sctp_Map_t m1;
 779     Sctp_Map_t *m = &m1;
 780     addToEpoll(epoll_fd, peerinfo, numberTwo, m, (char*)"enodeb1", numberZero);
 781 }
 782
 783 TEST(sctp, TEST11) {
 784     sctp_params_t sctpParams;
 785     int argc = 5;
 786     char **argv = (char**) calloc(argc, sizeof(char*));
 787     argv[numberZero] = (char*) malloc(numberForty * sizeof(char));
 788     argv[numberOne] = (char*) malloc(numberForty * sizeof(char));
 789     argv[numberTwo] = (char*) malloc(numberForty * sizeof(char));
 790     argv[numberThree] = (char*) malloc(numberForty * sizeof(char));
 791     argv[numberFour] = (char*) malloc(numberForty * sizeof(char));
 792     snprintf(argv[numberZero], strlen("./e2 "), "%s", (char*)"./e2");
 793     snprintf(argv[numberOne], strlen("-p "), "%s", (char*)"-p");
 794     snprintf(argv[numberTwo], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config");
 795     snprintf(argv[numberThree], strlen("-f "), "%s", (char*)"-f");
 796     snprintf(argv[numberFour], strlen("config.conf "), "%s", (char*)"config.conf");
 797
 798     auto result = parse(argc, argv, sctpParams);
 799     sctpParams.podName.assign("E2TermAlpha_pod");
 800     sctpParams.sctpMap = new mapWrapper();
 801     sctpParams.epoll_fd = epoll_create1(numberZero);
 802     buildConfiguration(sctpParams);
 803     // getRmrContext(sctpParams);
 804     buildInotify(sctpParams);
 805     sctpParams.inotifyFD = negativeOne;
 806     buildInotify(sctpParams);
 807     sctpParams.inotifyWD = negativeOne;
 808     buildInotify(sctpParams);
 809     buildListeningPort(sctpParams);
 810     listener(&sctpParams);
 811
 812     if(sctpParams.sctpMap) {
 813         delete sctpParams.sctpMap;
 814         sctpParams.sctpMap = NULL;
 815     }
 816     if(argv) {
 817         free(argv[numberZero]);
 818         argv[numberZero] = NULL;
 819         free(argv[numberOne]);
 820         argv[numberOne] = NULL;
 821         free(argv[numberTwo]);
 822         argv[numberTwo] = NULL;
 823         free(argv[numberThree]);
 824         argv[numberThree] = NULL;
 825         free(argv[numberFour]);
 826         argv[numberFour] = NULL;
 827         free(argv);
 828         argv=NULL;
 829     }
 830 }
 831
 832 TEST(sctp, TEST12) {
 833     ReportingMessages_t     reporting_msg;
 834     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 835     sendSctpMsg(peerInfo, reporting_msg, sctpMap);
 836
 837     if(sctpMap) {
 838         delete sctpMap;
 839         sctpMap = NULL;
 840     }
 841 }
 842
 843 /*TEST13 Begin*/
 844
 845 void inti_buffers_rcv(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 846     message.peerInfo = peerInfo;
 847     snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
 848
 849     rmrMessageBuffer.rcvMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 850     rmrMessageBuffer.rcvMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 851     rmrMessageBuffer.rcvMessage->len = strlen("Saying Hello from Ramji ");
 852     rmrMessageBuffer.rcvMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
 853
 854     rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 855     rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 856     rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji ");
 857     rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
 858
 859 }
 860
 861 void delete_memories_rcv(RmrMessagesBuffer_t &rmrMessageBuffer) {
 862
 863     if(rmrMessageBuffer.rcvMessage && rmrMessageBuffer.rcvMessage->header) {
 864         free(rmrMessageBuffer.rcvMessage->header);
 865         rmrMessageBuffer.rcvMessage->header = NULL;
 866     }
 867     if(rmrMessageBuffer.rcvMessage) {
 868         free(rmrMessageBuffer.rcvMessage);
 869         rmrMessageBuffer.rcvMessage = NULL;
 870     }
 871     if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
 872         free(rmrMessageBuffer.sendMessage->header);
 873         rmrMessageBuffer.sendMessage->header = NULL;
 874     }
 875     if(rmrMessageBuffer.sendMessage) {
 876         free(rmrMessageBuffer.sendMessage);
 877         rmrMessageBuffer.sendMessage = NULL;
 878     }
 879
 880 }
 881
 882 void create_receiveXappMessages_RIC_ERROR_INDICATION(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 883         RmrMessagesBuffer_t &rmrMessageBuffer) {
 884     inti_buffers_rcv(message, rmrMessageBuffer);
 885     rmrMessageBuffer.rcvMessage->mtype = RIC_ERROR_INDICATION;
 886     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 887     delete_memories_rcv(rmrMessageBuffer);
 888
 889 }
 890 void create_receiveXappMessages_RIC_E2_SETUP_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 891         RmrMessagesBuffer_t &rmrMessageBuffer) {
 892     inti_buffers_rcv(message, rmrMessageBuffer);
 893     rmrMessageBuffer.rcvMessage->mtype = RIC_E2_SETUP_FAILURE;
 894     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 895     delete_memories_rcv(rmrMessageBuffer);
 896 }
 897
 898 void create_receiveXappMessages_RIC_SUB_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 899         RmrMessagesBuffer_t &rmrMessageBuffer) {
 900     inti_buffers_rcv(message, rmrMessageBuffer);
 901     rmrMessageBuffer.rcvMessage->mtype = RIC_SUB_REQ;
 902     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 903     delete_memories_rcv(rmrMessageBuffer);
 904 }
 905
 906 void create_receiveXappMessages_RIC_CONTROL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 907         RmrMessagesBuffer_t &rmrMessageBuffer) {
 908     inti_buffers_rcv(message, rmrMessageBuffer);
 909     rmrMessageBuffer.rcvMessage->mtype = RIC_CONTROL_REQ;
 910     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 911     delete_memories_rcv(rmrMessageBuffer);
 912 }
 913
 914 void create_receiveXappMessages_RIC_SERVICE_QUERY(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 915         RmrMessagesBuffer_t &rmrMessageBuffer) {
 916     inti_buffers_rcv(message, rmrMessageBuffer);
 917     rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_QUERY;
 918     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 919     delete_memories_rcv(rmrMessageBuffer);
 920 }
 921
 922 void create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 923         RmrMessagesBuffer_t &rmrMessageBuffer) {
 924     inti_buffers_rcv(message, rmrMessageBuffer);
 925     rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_ACK;
 926     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 927     delete_memories_rcv(rmrMessageBuffer);
 928 }
 929
 930 void create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 931         RmrMessagesBuffer_t &rmrMessageBuffer) {
 932     inti_buffers_rcv(message, rmrMessageBuffer);
 933     rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_FAILURE;
 934     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 935     delete_memories_rcv(rmrMessageBuffer);
 936 }
 937
 938
 939 void create_receiveXappMessages_RIC_E2_RESET_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 940         RmrMessagesBuffer_t &rmrMessageBuffer) {
 941     inti_buffers_rcv(message, rmrMessageBuffer);
 942     rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_REQ;
 943     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 944     delete_memories_rcv(rmrMessageBuffer);
 945 }
 946
 947 void create_receiveXappMessages_RIC_E2_RESET_RESP(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 948         RmrMessagesBuffer_t &rmrMessageBuffer) {
 949     inti_buffers_rcv(message, rmrMessageBuffer);
 950     rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_RESP;
 951     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 952     delete_memories_rcv(rmrMessageBuffer);
 953 }
 954
 955 void create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 956         RmrMessagesBuffer_t &rmrMessageBuffer) {
 957     inti_buffers_rcv(message, rmrMessageBuffer);
 958     rmrMessageBuffer.rcvMessage->mtype = RIC_SCTP_CLEAR_ALL;
 959     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 960     delete_memories_rcv(rmrMessageBuffer);
 961 }
 962
 963 void create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 964         RmrMessagesBuffer_t &rmrMessageBuffer) {
 965     inti_buffers_rcv(message, rmrMessageBuffer);
 966     rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_REQ;
 967     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 968     delete_memories_rcv(rmrMessageBuffer);
 969 }
 970
 971 void create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 972         RmrMessagesBuffer_t &rmrMessageBuffer) {
 973     inti_buffers_rcv(message, rmrMessageBuffer);
 974     rmrMessageBuffer.rcvMessage->mtype = E2_TERM_KEEP_ALIVE_REQ;
 975     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 976     delete_memories_rcv(rmrMessageBuffer);
 977 }
 978
 979 void create_receiveXappMessages_RIC_SUB_DEL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 980         RmrMessagesBuffer_t &rmrMessageBuffer) {
 981         inti_buffers_rcv(message, rmrMessageBuffer);
 982         rmrMessageBuffer.rcvMessage->mtype = RIC_SUB_DEL_REQ;
 983         receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 984         delete_memories_rcv(rmrMessageBuffer);
 985 }
 986
 987 void create_receiveXappMessages_RIC_E2_SETUP_RESP(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 988         RmrMessagesBuffer_t &rmrMessageBuffer) {
 989         inti_buffers_rcv(message, rmrMessageBuffer);
 990         rmrMessageBuffer.rcvMessage->mtype = RIC_E2_SETUP_RESP;
 991         receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
 992         delete_memories_rcv(rmrMessageBuffer);
 993 }
 994
 995 void create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
 996         RmrMessagesBuffer_t &rmrMessageBuffer) {
 997         inti_buffers_rcv(message, rmrMessageBuffer);
 998         rmrMessageBuffer.rcvMessage->mtype = RIC_E2NODE_CONFIG_UPDATE_ACK;
 999         receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
1000         delete_memories_rcv(rmrMessageBuffer);
1001 }
1002
1003 void create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
1004         RmrMessagesBuffer_t &rmrMessageBuffer) {
1005         inti_buffers_rcv(message, rmrMessageBuffer);
1006         rmrMessageBuffer.rcvMessage->mtype = RIC_E2NODE_CONFIG_UPDATE_FAILURE;
1007         receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
1008         delete_memories_rcv(rmrMessageBuffer);
1009 }
1010
1011 TEST(sctp, TEST13) {
1012     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1013     ReportingMessages_t message;
1014     RmrMessagesBuffer_t rmrMessageBuffer;
1015
1016     memset( (void*)&message, numberZero, sizeof(message));
1017     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1018
1019     // Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset
1020     create_receiveXappMessages_RIC_E2_SETUP_FAILURE(sctpMap, message, rmrMessageBuffer);
1021     create_receiveXappMessages_RIC_ERROR_INDICATION(sctpMap, message, rmrMessageBuffer);
1022     create_receiveXappMessages_RIC_SUB_REQ(sctpMap, message, rmrMessageBuffer);
1023     create_receiveXappMessages_RIC_CONTROL_REQ(sctpMap, message, rmrMessageBuffer);
1024     create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(sctpMap, message, rmrMessageBuffer);
1025     create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(sctpMap, message, rmrMessageBuffer);
1026     create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
1027     create_receiveXappMessages_RIC_E2_RESET_RESP(sctpMap, message, rmrMessageBuffer);
1028     create_receiveXappMessages_RIC_E2_RESET_REQ(sctpMap, message, rmrMessageBuffer);
1029     create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer);
1030     create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(sctpMap, message, rmrMessageBuffer);
1031     create_receiveXappMessages_RIC_SERVICE_QUERY(sctpMap, message, rmrMessageBuffer);
1032     create_receiveXappMessages_RIC_SUB_DEL_REQ(sctpMap, message, rmrMessageBuffer);
1033     create_receiveXappMessages_RIC_E2_SETUP_RESP(sctpMap, message, rmrMessageBuffer);
1034     create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_ACK(sctpMap, message, rmrMessageBuffer);
1035     create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer);
1036
1037     inti_buffers_rcv(message, rmrMessageBuffer);
1038     rmrMessageBuffer.rcvMessage->mtype = 52345; /*Dummy Integer Value for default case*/
1039     receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
1040     delete_memories_rcv(rmrMessageBuffer);
1041
1042     if(sctpMap) {
1043         delete sctpMap;
1044         sctpMap = NULL;
1045     }
1046     resetToDefaultValueAsTeardown(message.message.enodbName);
1047     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1048 }
1049
1050 TEST(sctp, TESTForDebug) {
1051 char* log_level = "4";
1052 update_mdc_log_level_severity(log_level);
1053 }
1054
1055 TEST(sctp, TestE2SetupRequest) {
1056     E2AP_PDU_t              pdu;
1057     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1058     ReportingMessages_t     message;
1059     RmrMessagesBuffer_t     rmrMessageBuffer;
1060     sctp_params_t           sctp_ut_params;
1061
1062     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1063     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1064     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1065     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1066
1067     pdu.present = E2AP_PDU_PR_initiatingMessage;
1068     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1069     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1070     memset( (void*)&message, numberZero, sizeof(message));
1071     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1072
1073     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1074     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1075
1076     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1077
1078     resetToDefaultValueAsTeardown(message.message.enodbName);
1079     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1080
1081     if(pdu.choice.initiatingMessage) {
1082         free(pdu.choice.initiatingMessage);
1083         pdu.choice.initiatingMessage = NULL;
1084     }
1085     if(sctpMap) {
1086         delete sctpMap;
1087         sctpMap = NULL;
1088     }
1089 }
1090
1091 TEST(sctp, TestE2SetupRequestWhenReceivedWithoutTransactionIDThenIgnoreE2SetupProcedure) {
1092     E2AP_PDU_t              pdu;
1093     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1094     ReportingMessages_t     message;
1095     RmrMessagesBuffer_t     rmrMessageBuffer;
1096     sctp_params_t           sctp_ut_params;
1097     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1098     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1099     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1100     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1101
1102     pdu.present = E2AP_PDU_PR_initiatingMessage;
1103     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1104     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1105     memset( (void*)&message, numberZero, sizeof(message));
1106     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1107
1108     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1109     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1110
1111     create_asnInitiatingReq_Procedure_E2SetupWithoutTransactionID(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1112
1113     resetToDefaultValueAsTeardown(message.message.enodbName);
1114     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1115
1116     if(pdu.choice.initiatingMessage) {
1117         free(pdu.choice.initiatingMessage);
1118         pdu.choice.initiatingMessage = NULL;
1119     }
1120     if(sctpMap) {
1121         delete sctpMap;
1122         sctpMap = NULL;
1123     }
1124 }
1125
1126
1127 TEST(sctp, TestErrorIndicationWhenE2SetupOngoingProcedureOccurred) {
1128     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1129     ReportingMessages_t message;
1130     RmrMessagesBuffer_t rmrMessageBuffer;
1131     E2AP_PDU_t              pdu;
1132     sctp_params_t           sctp_ut_params;
1133     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1134     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1135     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1136     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1137
1138     pdu.present = E2AP_PDU_PR_initiatingMessage;
1139     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1140     memset( (void*)&message, numberZero, sizeof(message));
1141     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1142     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1143
1144     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1145
1146     create_receiveXappMessages_RIC_E2_SETUP_RESP(sctpMap, message, rmrMessageBuffer);
1147
1148     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1149
1150     create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1151     resetToDefaultValueAsTeardown(message.message.enodbName);
1152     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1153
1154     if(pdu.choice.initiatingMessage) {
1155         free(pdu.choice.initiatingMessage);
1156         pdu.choice.initiatingMessage = NULL;
1157     }
1158
1159     if(sctpMap) {
1160         delete sctpMap;
1161         sctpMap = NULL;
1162     }
1163 }
1164
1165
1166 TEST(sctp, TestE2SetupRequestReceivedThenErrorIndicationMessageTriggered) {
1167     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1168     ReportingMessages_t message;
1169     RmrMessagesBuffer_t rmrMessageBuffer;
1170     E2AP_PDU_t              pdu;
1171     sctp_params_t           sctp_ut_params;
1172     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1173     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1174     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1175     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1176
1177     pdu.present = E2AP_PDU_PR_initiatingMessage;
1178     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1179     memset( (void*)&message, numberZero, sizeof(message));
1180     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1181     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1182     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1183     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1184     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1185
1186     create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1187
1188     resetToDefaultValueAsTeardown(message.message.enodbName);
1189     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1190
1191     if(pdu.choice.initiatingMessage) {
1192         free(pdu.choice.initiatingMessage);
1193         pdu.choice.initiatingMessage = NULL;
1194     }
1195
1196     if(sctpMap) {
1197         delete sctpMap;
1198         sctpMap = NULL;
1199     }
1200 }
1201
1202 TEST(sctp, TestE2SetupRequestReceivedThenRICindicationMessageTriggered) {
1203     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1204     ReportingMessages_t message;
1205     RmrMessagesBuffer_t rmrMessageBuffer;
1206     E2AP_PDU_t              pdu;
1207     sctp_params_t           sctp_ut_params;
1208     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1209     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1210     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1211     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1212
1213     pdu.present = E2AP_PDU_PR_initiatingMessage;
1214     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1215     memset( (void*)&message, numberZero, sizeof(message));
1216     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1217     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1218     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1219     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1220     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1221
1222     create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1223
1224     resetToDefaultValueAsTeardown(message.message.enodbName);
1225     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1226
1227     if(pdu.choice.initiatingMessage) {
1228         free(pdu.choice.initiatingMessage);
1229         pdu.choice.initiatingMessage = NULL;
1230     }
1231
1232     if(sctpMap) {
1233         delete sctpMap;
1234         sctpMap = NULL;
1235     }
1236 }
1237 TEST(sctp, TestE2SetupRequestReceivedThenRICserviceUpdateMessageTriggered) {
1238     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1239     ReportingMessages_t message;
1240     RmrMessagesBuffer_t rmrMessageBuffer;
1241     E2AP_PDU_t              pdu;
1242     sctp_params_t           sctp_ut_params;
1243     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1244     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1245     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1246     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1247
1248     pdu.present = E2AP_PDU_PR_initiatingMessage;
1249     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1250     memset( (void*)&message, numberZero, sizeof(message));
1251     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1252     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1253     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1254     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1255     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1256
1257     create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1258
1259     resetToDefaultValueAsTeardown(message.message.enodbName);
1260     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1261
1262     if(pdu.choice.initiatingMessage) {
1263         free(pdu.choice.initiatingMessage);
1264         pdu.choice.initiatingMessage = NULL;
1265     }
1266
1267     if(sctpMap) {
1268         delete sctpMap;
1269         sctpMap = NULL;
1270     }
1271 }
1272
1273 TEST(sctp, TestE2SetupRequestReceivedThenResetMessageTriggered) {
1274     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1275     ReportingMessages_t message;
1276     RmrMessagesBuffer_t rmrMessageBuffer;
1277     E2AP_PDU_t              pdu;
1278     sctp_params_t           sctp_ut_params;
1279     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1280     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1281     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1282     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1283
1284     pdu.present = E2AP_PDU_PR_initiatingMessage;
1285     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1286     memset( (void*)&message, numberZero, sizeof(message));
1287     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1288     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1289     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1290     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1291     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1292
1293     create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1294
1295     resetToDefaultValueAsTeardown(message.message.enodbName);
1296     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1297
1298     if(pdu.choice.initiatingMessage) {
1299         free(pdu.choice.initiatingMessage);
1300         pdu.choice.initiatingMessage = NULL;
1301     }
1302
1303     if(sctpMap) {
1304         delete sctpMap;
1305         sctpMap = NULL;
1306     }
1307 }
1308 TEST(sctp, TestE2SetupRequestReceivedThenRICcontrolMessageTriggered) {
1309     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1310     ReportingMessages_t message;
1311     RmrMessagesBuffer_t rmrMessageBuffer;
1312     E2AP_PDU_t              pdu;
1313     sctp_params_t           sctp_ut_params;
1314     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1315     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1316     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1317     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1318
1319     pdu.present = E2AP_PDU_PR_initiatingMessage;
1320     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1321     memset( (void*)&message, numberZero, sizeof(message));
1322     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1323     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1324     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1325     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1326     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1327
1328     create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1329
1330     resetToDefaultValueAsTeardown(message.message.enodbName);
1331     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1332
1333     if(pdu.choice.initiatingMessage) {
1334         free(pdu.choice.initiatingMessage);
1335         pdu.choice.initiatingMessage = NULL;
1336     }
1337
1338     if(sctpMap) {
1339         delete sctpMap;
1340         sctpMap = NULL;
1341     }
1342 }
1343
1344 TEST(sctp, TestE2SetupRequestReceivedThenRICcontrolMessageTriggeredAndGotControlFailure) {
1345     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1346     ReportingMessages_t message;
1347     RmrMessagesBuffer_t rmrMessageBuffer;
1348     E2AP_PDU_t              pdu;
1349     sctp_params_t           sctp_ut_params;
1350     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1351     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1352     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1353     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1354
1355     pdu.present = E2AP_PDU_PR_initiatingMessage;
1356     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1357     memset( (void*)&message, numberZero, sizeof(message));
1358     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1359     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1360     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1361     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1362     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1363
1364     create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1365
1366     resetToDefaultValueAsTeardown(message.message.enodbName);
1367     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1368
1369     if(pdu.choice.initiatingMessage) {
1370         free(pdu.choice.initiatingMessage);
1371         pdu.choice.initiatingMessage = NULL;
1372     }
1373
1374     if(sctpMap) {
1375         delete sctpMap;
1376         sctpMap = NULL;
1377     }
1378 }
1379
1380 TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionMessageTriggered) {
1381     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1382     ReportingMessages_t message;
1383     RmrMessagesBuffer_t rmrMessageBuffer;
1384     E2AP_PDU_t              pdu;
1385     sctp_params_t           sctp_ut_params;
1386     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1387     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1388     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1389     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1390
1391     pdu.present = E2AP_PDU_PR_initiatingMessage;
1392     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1393     memset( (void*)&message, numberZero, sizeof(message));
1394     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1395     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1396     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1397     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1398     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1399
1400     create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1401
1402     resetToDefaultValueAsTeardown(message.message.enodbName);
1403     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1404
1405     if(pdu.choice.initiatingMessage) {
1406         free(pdu.choice.initiatingMessage);
1407         pdu.choice.initiatingMessage = NULL;
1408     }
1409
1410     if(sctpMap) {
1411         delete sctpMap;
1412         sctpMap = NULL;
1413     }
1414 }
1415
1416 TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionMessageTriggeredAndGotSubsFailure) {
1417     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1418     ReportingMessages_t message;
1419     RmrMessagesBuffer_t rmrMessageBuffer;
1420     E2AP_PDU_t              pdu;
1421     sctp_params_t           sctp_ut_params;
1422     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1423     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1424     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1425     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1426
1427     pdu.present = E2AP_PDU_PR_initiatingMessage;
1428     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1429     memset( (void*)&message, numberZero, sizeof(message));
1430     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1431     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1432     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1433     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1434     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1435
1436     create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1437
1438     resetToDefaultValueAsTeardown(message.message.enodbName);
1439     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1440
1441     if(pdu.choice.initiatingMessage) {
1442         free(pdu.choice.initiatingMessage);
1443         pdu.choice.initiatingMessage = NULL;
1444     }
1445
1446     if(sctpMap) {
1447         delete sctpMap;
1448         sctpMap = NULL;
1449     }
1450 }
1451
1452 TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionDeleteMessageTriggered) {
1453     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1454     ReportingMessages_t message;
1455     RmrMessagesBuffer_t rmrMessageBuffer;
1456     E2AP_PDU_t              pdu;
1457     sctp_params_t           sctp_ut_params;
1458     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1459     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1460     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1461     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1462
1463     pdu.present = E2AP_PDU_PR_initiatingMessage;
1464     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1465     memset( (void*)&message, numberZero, sizeof(message));
1466     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1467     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1468     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1469     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1470     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1471
1472     create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1473     resetToDefaultValueAsTeardown(message.message.enodbName);
1474
1475     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1476
1477     if(pdu.choice.initiatingMessage) {
1478         free(pdu.choice.initiatingMessage);
1479         pdu.choice.initiatingMessage = NULL;
1480     }
1481
1482     if(sctpMap) {
1483         delete sctpMap;
1484         sctpMap = NULL;
1485     }
1486 }
1487
1488 TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionDeleteMessageTriggeredAndGotSubDelFailure) {
1489     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1490     ReportingMessages_t message;
1491     RmrMessagesBuffer_t rmrMessageBuffer;
1492     E2AP_PDU_t              pdu;
1493     sctp_params_t           sctp_ut_params;
1494     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1495     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1496     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1497     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1498
1499     pdu.present = E2AP_PDU_PR_initiatingMessage;
1500     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1501     memset( (void*)&message, numberZero, sizeof(message));
1502     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1503     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1504     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1505     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1506     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1507
1508     create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1509     resetToDefaultValueAsTeardown(message.message.enodbName);
1510
1511     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1512
1513     if(pdu.choice.initiatingMessage) {
1514         free(pdu.choice.initiatingMessage);
1515         pdu.choice.initiatingMessage = NULL;
1516     }
1517
1518     if(sctpMap) {
1519         delete sctpMap;
1520         sctpMap = NULL;
1521     }
1522 }
1523
1524 void errorIndicationBasedOnProcedureCodeOrProcedureStatus(E2AP_PDU_t *pdu,
1525         Sctp_Map_t *sctpMap,
1526         ReportingMessages_t &message,
1527         RmrMessagesBuffer_t &rmrMessageBuffer,
1528         sctp_params_t &sctp_ut_params) {
1529
1530     init_memories(message, rmrMessageBuffer, sctp_ut_params);
1531
1532     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication;
1533     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication;
1534
1535     pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array = (ErrorIndication_IEs**) malloc(1 * sizeof(ErrorIndication_IEs*));
1536     pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count = 1;
1537     pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.size = sizeof(ErrorIndication_IEs);
1538     pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero] = (ErrorIndication_IEs*) malloc(sizeof(ErrorIndication_IEs));
1539
1540     ErrorIndication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero];
1541
1542     ie->id = ProtocolIE_ID_id_TransactionID;
1543     ie->criticality = Criticality_reject;
1544     ie->value.present = ErrorIndication_IEs__value_PR_TransactionID;
1545     ie->value.choice.TransactionID = numberThree;
1546
1547     int streamId = numberZero;
1548
1549     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer, streamId);
1550     delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, true);
1551 }
1552
1553 TEST(sctp, TestDropErrorIndicationReceivedWithInvalidTidWhenE2SetupOngoingProcedureOccurredBasedOnOngoingProcedureStatus) {
1554     Sctp_Map_t *sctpMap = new Sctp_Map_t();
1555     ReportingMessages_t message;
1556     RmrMessagesBuffer_t rmrMessageBuffer;
1557     E2AP_PDU_t              pdu;
1558     sctp_params_t           sctp_ut_params;
1559     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1560     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1561     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1562     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1563
1564     pdu.present = E2AP_PDU_PR_initiatingMessage;
1565     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1566     memset( (void*)&message, numberZero, sizeof(message));
1567     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1568     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1569     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1570     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1571     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1572
1573     errorIndicationBasedOnProcedureCodeOrProcedureStatus(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1574
1575     resetToDefaultValueAsTeardown(message.message.enodbName);
1576     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1577
1578     if(pdu.choice.initiatingMessage) {
1579         free(pdu.choice.initiatingMessage);
1580         pdu.choice.initiatingMessage = NULL;
1581     }
1582
1583     if(sctpMap) {
1584         delete sctpMap;
1585         sctpMap = NULL;
1586     }
1587 }
1588
1589 TEST(sctp, TestRemovalOfE2ConnectionEntryFromMap) {
1590
1591     E2AP_PDU_t              pdu;
1592     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1593     ReportingMessages_t     message;
1594     RmrMessagesBuffer_t     rmrMessageBuffer;
1595     sctp_params_t           sctp_ut_params;
1596
1597     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1598     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1599     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1600     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1601
1602     pdu.present = E2AP_PDU_PR_initiatingMessage;
1603     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1604     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1605     memset( (void*)&message, numberZero, sizeof(message));
1606     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1607
1608     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1609     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1610
1611     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1612
1613     removeE2ConnectionEntryFromMap(message.message.enodbName);
1614
1615     resetToDefaultValueAsTeardown(message.message.enodbName);
1616     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1617
1618     if(pdu.choice.initiatingMessage) {
1619         free(pdu.choice.initiatingMessage);
1620         pdu.choice.initiatingMessage = NULL;
1621     }
1622     if(sctpMap) {
1623         delete sctpMap;
1624         sctpMap = NULL;
1625     }
1626 }
1627
1628 TEST(sctp, TestUnsupportedRicSubsDelRequiredBeforeE2SetupReqThenE2TShouldNotCrash) {
1629     E2AP_PDU_t              pdu;
1630     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1631     ReportingMessages_t     message;
1632     RmrMessagesBuffer_t     rmrMessageBuffer;
1633     sctp_params_t           sctp_ut_params;
1634     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1635     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1636     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1637     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1638
1639     pdu.present = E2AP_PDU_PR_initiatingMessage;
1640     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1641     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1642     memset( (void*)&message, numberZero, sizeof(message));
1643     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1644
1645     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1646     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1647
1648     unsupportedRicSubscriptionDelReq(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1649
1650     if(pdu.choice.initiatingMessage) {
1651         free(pdu.choice.initiatingMessage);
1652         pdu.choice.initiatingMessage = NULL;
1653     }
1654     if(sctpMap) {
1655         delete sctpMap;
1656         sctpMap = NULL;
1657     }
1658     resetToDefaultValueAsTeardown(message.message.enodbName);
1659     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1660 }
1661
1662 TEST(sctp, TestUnsupportedRicSubsDelRequiredAfterE2SetupReqThenE2TShouldNotCrash) {
1663     E2AP_PDU_t              pdu;
1664     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1665     ReportingMessages_t     message;
1666     RmrMessagesBuffer_t     rmrMessageBuffer;
1667     sctp_params_t           sctp_ut_params;
1668     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1669     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1670     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1671     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1672
1673     pdu.present = E2AP_PDU_PR_initiatingMessage;
1674     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1675     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1676     memset( (void*)&message, numberZero, sizeof(message));
1677     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1678
1679     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1680     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1681
1682     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1683
1684     unsupportedRicSubscriptionDelReq(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1685
1686     if(pdu.choice.initiatingMessage) {
1687         free(pdu.choice.initiatingMessage);
1688         pdu.choice.initiatingMessage = NULL;
1689     }
1690     if(sctpMap) {
1691         delete sctpMap;
1692         sctpMap = NULL;
1693     }
1694     resetToDefaultValueAsTeardown(message.message.enodbName);
1695     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1696 }
1697
1698 TEST(sctp, TestUnsupportedE2ConnectionUpdateAckBeforeE2SetupReqThenE2TShouldNotCrash) {
1699     E2AP_PDU_t              pdu;
1700     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1701     ReportingMessages_t     message;
1702     RmrMessagesBuffer_t     rmrMessageBuffer;
1703     sctp_params_t           sctp_ut_params;
1704
1705     pdu.present = E2AP_PDU_PR_initiatingMessage;
1706     pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
1707     memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome));
1708     memset( (void*)&message, numberZero, sizeof(message));
1709     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1710
1711     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1712     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1713
1714     unsupportedE2ConnectionUpdateAck(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1715
1716     if(pdu.choice.successfulOutcome) {
1717         free(pdu.choice.successfulOutcome);
1718         pdu.choice.successfulOutcome = NULL;
1719     }
1720     if(sctpMap) {
1721         delete sctpMap;
1722         sctpMap = NULL;
1723     }
1724     resetToDefaultValueAsTeardown(message.message.enodbName);
1725     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1726 }
1727
1728 TEST(sctp, TestUnsupportedE2ConnectionUpdateAckAfterE2SetupReqThenE2TShouldNotCrash) {
1729     E2AP_PDU_t              pdu;
1730     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1731     ReportingMessages_t     message;
1732     RmrMessagesBuffer_t     rmrMessageBuffer;
1733     sctp_params_t           sctp_ut_params;
1734     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1735     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1736     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1737     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1738
1739     pdu.present = E2AP_PDU_PR_initiatingMessage;
1740     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1741     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1742     memset( (void*)&message, numberZero, sizeof(message));
1743     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1744
1745     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1746     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1747
1748     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1749
1750     pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
1751     memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome));
1752
1753     unsupportedE2ConnectionUpdateAck(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1754     resetToDefaultValueAsTeardown(message.message.enodbName);
1755     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1756
1757     if(pdu.choice.initiatingMessage) {
1758         free(pdu.choice.initiatingMessage);
1759         pdu.choice.initiatingMessage = NULL;
1760     }
1761     if(pdu.choice.successfulOutcome) {
1762         free(pdu.choice.successfulOutcome);
1763         pdu.choice.successfulOutcome = NULL;
1764     }
1765     if(sctpMap) {
1766         delete sctpMap;
1767         sctpMap = NULL;
1768     }
1769
1770 }
1771
1772 TEST(sctp, TestUnsupportedE2ConnectionUpdateFailBeforeE2SetupReqThenE2TShouldNotCrash) {
1773     E2AP_PDU_t              pdu;
1774     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1775     ReportingMessages_t     message;
1776     RmrMessagesBuffer_t     rmrMessageBuffer;
1777     sctp_params_t           sctp_ut_params;
1778
1779     pdu.present = E2AP_PDU_PR_initiatingMessage;
1780     pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
1781     memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome));
1782     memset( (void*)&message, numberZero, sizeof(message));
1783     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1784
1785     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1786     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1787
1788     unsupportedE2ConnectionUpdateFail(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1789
1790     if(pdu.choice.unsuccessfulOutcome) {
1791         free(pdu.choice.unsuccessfulOutcome);
1792         pdu.choice.unsuccessfulOutcome = NULL;
1793     }
1794     if(sctpMap) {
1795         delete sctpMap;
1796         sctpMap = NULL;
1797     }
1798     resetToDefaultValueAsTeardown(message.message.enodbName);
1799     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1800 }
1801
1802 TEST(sctp, TestUnsupportedE2ConnectionUpdateFailAfterE2SetupReqThenE2TShouldNotCrash) {
1803     E2AP_PDU_t              pdu;
1804     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
1805     ReportingMessages_t     message;
1806     RmrMessagesBuffer_t     rmrMessageBuffer;
1807     sctp_params_t           sctp_ut_params;
1808     struct E2NodeConnectionHandling e2NodeConnectionHandling;
1809     memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1810     e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1811     e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1812
1813     pdu.present = E2AP_PDU_PR_initiatingMessage;
1814     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1815     memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1816     memset( (void*)&message, numberZero, sizeof(message));
1817     memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1818
1819     snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1820     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1821
1822     create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1823
1824     pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
1825     memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome));
1826
1827     unsupportedE2ConnectionUpdateFail(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1828
1829     if(pdu.choice.initiatingMessage) {
1830         free(pdu.choice.initiatingMessage);
1831         pdu.choice.initiatingMessage = NULL;
1832     }
1833     if(pdu.choice.unsuccessfulOutcome) {
1834         free(pdu.choice.unsuccessfulOutcome);
1835         pdu.choice.unsuccessfulOutcome = NULL;
1836     }
1837     if(sctpMap) {
1838         delete sctpMap;
1839         sctpMap = NULL;
1840     }
1841     resetToDefaultValueAsTeardown(message.message.enodbName);
1842     ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1843 }
1844
1845 TEST(sctp, TestForInfo) {
1846 char* log_level = "3";
1847 update_mdc_log_level_severity(log_level);
1848 }
1849
1850 TEST(sctp, TestForWarn) {
1851 char* log_level = "2";
1852 update_mdc_log_level_severity(log_level);
1853 }
1854
1855 TEST(sctp, TestForErr) {
1856 char* log_level = "1";
1857 update_mdc_log_level_severity(log_level);
1858 }
1859
1860 int main(int argc, char **argv) {
1861
1862    testing::InitGoogleTest(&argc, argv);
1863    return RUN_ALL_TESTS();
1864 }