RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp

   1 #include <gtest/gtest.h>
   2 #include <gmock/gmock.h>
   3 #include "sctpThread.h"
   4 #include <sys/epoll.h>
   5 #include "E2AP-PDU.h"
   6
   7 using namespace testing;
   8
   9 typedef struct {
  10     int32_t mtype;                      // message type  ("long" network integer)
  11     int32_t     plen;                       // payload length (sender data length in payload)
  12     int32_t rmr_ver;                    // our internal message version number
  13     unsigned char xid[RMR_MAX_XID];         // space for user transaction id or somesuch
  14     unsigned char sid[RMR_MAX_SID];         // sender ID for return to sender needs
  15     unsigned char src[RMR_MAX_SRC];         // name:port of the sender (source)
  16     unsigned char meid[RMR_MAX_MEID];   // managed element id.
  17     struct timespec     ts;                 // timestamp ???
  18     int32_t     flags;                      // HFL_* constants
  19     int32_t     len0;                       // length of the RMr header data
  20     int32_t     len1;                       // length of the tracing data
  21     int32_t     len2;                       // length of data 1 (d1)
  22     int32_t     len3;                       // length of data 2 (d2)
  23     int32_t     sub_id;                     // subscription id (-1 invalid)
  24
  25     unsigned char srcip[RMR_MAX_SRC];   // ip address and port of the source
  26 } uta_mhdr_t;
  27
  28 TEST(sctp, TEST1) {
  29     mdclog_level_set(MDCLOG_DEBUG);
  30     string s;
  31     s = translateRmrErrorMessages(0);
  32     EXPECT_THAT(s, HasSubstr("RMR_OK"));
  33     s = translateRmrErrorMessages(1);
  34     EXPECT_THAT(s, HasSubstr("RMR_ERR_BADARG"));
  35     s = translateRmrErrorMessages(2);
  36     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOENDPT"));
  37     s = translateRmrErrorMessages(3);
  38     EXPECT_THAT(s, HasSubstr("RMR_ERR_EMPTY"));
  39     s = translateRmrErrorMessages(4);
  40     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOHDR"));
  41     s = translateRmrErrorMessages(5);
  42     EXPECT_THAT(s, HasSubstr("RMR_ERR_SENDFAILED"));
  43     s = translateRmrErrorMessages(6);
  44     EXPECT_THAT(s, HasSubstr("RMR_ERR_CALLFAILED"));
  45     s = translateRmrErrorMessages(7);
  46     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOWHOPEN"));
  47     s = translateRmrErrorMessages(8);
  48     EXPECT_THAT(s, HasSubstr("RMR_ERR_WHID"));
  49     s = translateRmrErrorMessages(9);
  50     EXPECT_THAT(s, HasSubstr("RMR_ERR_OVERFLOW"));
  51     s = translateRmrErrorMessages(10);
  52     EXPECT_THAT(s, HasSubstr("RMR_ERR_RETRY"));
  53     s = translateRmrErrorMessages(11);
  54     EXPECT_THAT(s, HasSubstr("RMR_ERR_RCVFAILED"));
  55     s = translateRmrErrorMessages(12);
  56     EXPECT_THAT(s, HasSubstr("RMR_ERR_TIMEOUT"));
  57     s = translateRmrErrorMessages(13);
  58     EXPECT_THAT(s, HasSubstr("RMR_ERR_UNSET"));
  59     s = translateRmrErrorMessages(14);
  60     EXPECT_THAT(s, HasSubstr("RMR_ERR_TRUNC"));
  61     s = translateRmrErrorMessages(15);
  62     EXPECT_THAT(s, HasSubstr("RMR_ERR_INITFAILED"));
  63     s = translateRmrErrorMessages(16);
  64     EXPECT_THAT(s, HasSubstr("RMR_ERR_NOTSUPP"));
  65     s = translateRmrErrorMessages(17);
  66     EXPECT_THAT(s, HasSubstr("UNDOCUMENTED RMR_ERR"));
  67 }
  68
  69 auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t));
  70
  71 TEST(sctp, TEST2) {
  72     struct epoll_event event;
  73     event.events = EPOLLIN;
  74     event.data.fd = 0;
  75     ConnectedCU_t data1;
  76     ConnectedCU_t *data = &data1;
  77     event.data.ptr = (void *)data;
  78     sctp_params_t sctp_ut_params;
  79     sctp_params_t* sctp = &sctp_ut_params;
  80     ReportingMessages_t reporting_msg;
  81     RmrMessagesBuffer_t rmrmessagesbuffer;
  82     handleEinprogressMessages(event,reporting_msg,rmrmessagesbuffer,sctp);
  83 }
  84
  85 TEST(sctp, TEST3) {
  86     struct epoll_event event;
  87     event.events = EPOLLIN;
  88     event.data.fd = 0;
  89     ConnectedCU_t data1;
  90     ConnectedCU_t *data = &data1;
  91     event.data.ptr = (void *)data;
  92     sctp_params_t sctp_ut_params;
  93     sctp_params_t* sctp = &sctp_ut_params;
  94     Sctp_Map_t m1;
  95     sctp ->sctpMap =  &m1;
  96     ReportingMessages_t reporting_msg;
  97     RmrMessagesBuffer_t rmrmessagesbuffer;
  98     handlepoll_error(event,reporting_msg,rmrmessagesbuffer,sctp);
  99 }
 100
 101 TEST(sctp, TEST4) {
 102     ConnectedCU_t cu;
 103     ConnectedCU_t* connected_cu = &cu;
 104     Sctp_Map_t m1;
 105     Sctp_Map_t *m = &m1;
 106     cleanHashEntry(connected_cu,m);
 107 }
 108
 109 TEST(sctp, TEST5) {
 110     sctp_params_t sctp_ut_params;
 111     sctp_params_t* sctp = &sctp_ut_params;
 112     sctp->configFilePath.assign("/opt/e2/RIC-E2-TERMINATION/config/");
 113     sctp->configFileName.assign("config.conf");
 114     handleConfigChange(sctp);
 115 }
 116
 117 TEST(sctp, TEST6) {
 118     int epoll_fd = epoll_create1(0);
 119     ConnectedCU_t cu;
 120     ConnectedCU_t* peerinfo = &cu;
 121     Sctp_Map_t m1;
 122     Sctp_Map_t *m = &m1;
 123     modifyToEpoll(epoll_fd,peerinfo,2,m, (char*)"enodeb1",2);
 124 }
 125
 126 /* TEST7 Begin: */
 127 void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 128
 129     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
 130     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate;
 131     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate;
 132
 133     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
 134 }
 135
 136 void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 137
 138     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
 139     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication;
 140     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication;
 141     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*));
 142     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 1;
 143     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs);
 144     pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs));
 145     RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0];
 146     ie->id = ProtocolIE_ID_id_RICrequestID;
 147     ie->value.present = RICindication_IEs__value_PR_RICrequestID;
 148     ie->value.choice.RICrequestID.ricRequestorID = 12345;
 149     ie->value.choice.RICrequestID.ricInstanceID = 1;
 150
 151     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
 152 }
 153
 154 void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 155
 156     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
 157     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication;
 158     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication;
 159     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
 160 }
 161
 162 void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 163
 164     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
 165     pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 166     pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest;
 167     asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer);
 168 }
 169
 170 TEST(sctp, TEST7) {
 171     E2AP_PDU_t              pdu;
 172     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 173     ReportingMessages_t     message;
 174     RmrMessagesBuffer_t     rmrMessageBuffer;
 175     sctp_params_t           sctp_ut_params;
 176
 177     pdu.present = E2AP_PDU_PR_initiatingMessage;
 178     pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
 179     memset( (void*)pdu.choice.initiatingMessage, 0, sizeof(pdu.choice.initiatingMessage));
 180     memset( (void*)&message, 0, sizeof(message));
 181     memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
 182
 183     message.peerInfo = peerInfo;
 184     message.peerInfo->sctpParams = &sctp_ut_params;
 185     snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
 186
 187     sctp_ut_params.myIP = "1.2.3.4";
 188     sctp_ut_params.rmrPort = 38000;
 189     snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
 190     sctp_ut_params.prometheusRegistry = std::make_shared<Registry>();
 191     startPrometheus(sctp_ut_params);
 192
 193     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, RMRFL_NONE);
 194     rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 195     rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 196     rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji ");
 197     rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
 198
 199     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
 200     create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer);
 201     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
 202     create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer);
 203     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
 204     create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer);
 205     /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
 206     create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer);
 207     /* For Procedure's Default case. */
 208     pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100);
 209     asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer);
 210
 211     /* Put some usleep... */
 212     // usleep(2);
 213     if(pdu.choice.initiatingMessage)
 214         free(pdu.choice.initiatingMessage);
 215     if(rmrMessageBuffer.sendMessage->header)
 216         free(rmrMessageBuffer.sendMessage->header);
 217     if(rmrMessageBuffer.sendMessage)
 218         free(rmrMessageBuffer.sendMessage);
 219 }
 220
 221 /* TEXT8 Begin: */
 222 void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 223
 224     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
 225     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
 226     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 227 }
 228
 229 void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 230
 231     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*));
 232     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 1;
 233     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t);
 234     pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t));
 235     RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0];
 236
 237     ie->id = ProtocolIE_ID_id_RICrequestID;
 238     ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID;
 239     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 240     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
 241     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 242 }
 243
 244 void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 245
 246     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 247     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
 248     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 249 }
 250
 251 void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 252
 253     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 254     pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 255     asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 256 }
 257
 258 TEST(sctp, TEST8) {
 259     E2AP_PDU_t              pdu;
 260     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 261     ReportingMessages_t     message;
 262     RmrMessagesBuffer_t     rmrMessageBuffer;
 263     sctp_params_t           sctp_ut_params;
 264
 265     pdu.present = E2AP_PDU_PR_successfulOutcome;
 266     pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
 267     memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome));
 268     memset( (void*)&message, 0, sizeof(message));
 269     memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
 270
 271     message.peerInfo = peerInfo;
 272     message.peerInfo->sctpParams = &sctp_ut_params;
 273     snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
 274
 275     sctp_ut_params.myIP = "1.2.3.4";
 276     sctp_ut_params.rmrPort = 38000;
 277     snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
 278
 279     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, RMRFL_NONE);
 280     rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 281     rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 282     rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji ");
 283     rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
 284
 285     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
 286     create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer);
 287     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 288     create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer);
 289     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 290     create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer);
 291     /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 292     create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer);
 293     /* For Procedure's Default case. */
 294     pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100);
 295     asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
 296
 297     /*Put some usleep... */
 298     // usleep(2);
 299     if(pdu.choice.successfulOutcome)
 300         free(pdu.choice.successfulOutcome);
 301     if(rmrMessageBuffer.sendMessage->header)
 302         free(rmrMessageBuffer.sendMessage->header);
 303     if(rmrMessageBuffer.sendMessage)
 304         free(rmrMessageBuffer.sendMessage);
 305 }
 306
 307 /* TEST9 Begin: */
 308 void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 309
 310     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*));
 311     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 1;
 312     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t);
 313     pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t));
 314     RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0];
 315
 316     ie->id = ProtocolIE_ID_id_RICrequestID;
 317     ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID;
 318     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 319     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
 320     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 321 }
 322
 323 void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 324
 325     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 326     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
 327     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 328 }
 329
 330 void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
 331
 332     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 333     pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 334     asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
 335 }
 336
 337 TEST(sctp, TEST9) {
 338     E2AP_PDU_t              pdu;
 339     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 340     ReportingMessages_t     message;
 341     RmrMessagesBuffer_t     rmrMessageBuffer;
 342     sctp_params_t           sctp_ut_params;
 343
 344     pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
 345     pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
 346     memset( (void*)pdu.choice.unsuccessfulOutcome, 0, sizeof(pdu.choice.unsuccessfulOutcome));
 347     memset( (void*)&message, 0, sizeof(message));
 348     memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
 349
 350     message.peerInfo = peerInfo;
 351     message.peerInfo->sctpParams = &sctp_ut_params;
 352     snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
 353
 354     sctp_ut_params.myIP = "1.2.3.4";
 355     sctp_ut_params.rmrPort = 38000;
 356     snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
 357
 358     rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, RMRFL_NONE);
 359     rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
 360     rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
 361     rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji ");
 362     rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
 363
 364     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
 365     create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer);
 366     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
 367     create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer);
 368     /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
 369     create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer);
 370     /* For Procedure's Default case. */
 371     pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100);
 372     asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
 373
 374     if(pdu.choice.unsuccessfulOutcome)
 375         free(pdu.choice.unsuccessfulOutcome);
 376     if(rmrMessageBuffer.sendMessage->header)
 377         free(rmrMessageBuffer.sendMessage->header);
 378     if(rmrMessageBuffer.sendMessage)
 379         free(rmrMessageBuffer.sendMessage);
 380 }
 381
 382 TEST(sctp, TEST10) {
 383     int epoll_fd = epoll_create1(0);
 384     ConnectedCU_t cu;
 385     ConnectedCU_t* peerinfo = &cu;
 386     Sctp_Map_t m1;
 387     Sctp_Map_t *m = &m1;
 388     addToEpoll(epoll_fd, peerinfo, 2, m, (char*)"enodeb1", 0);
 389 }
 390
 391 TEST(sctp, TEST11) {
 392     sctp_params_t sctpParams;
 393     int argc = 5;
 394     char **argv = (char**) malloc(argc * sizeof(char*));
 395     argv[0] = "./e2";
 396     argv[1] = "-p";
 397     argv[2] = "/opt/e2/RIC-E2-TERMINATION/config/";
 398     argv[3] = "-f";
 399     argv[4] = "config.conf";
 400
 401     auto result = parse(argc, argv, sctpParams);
 402     sctpParams.podName.assign("E2TermAlpha_pod");
 403     buildConfiguration(sctpParams);
 404     sctpParams.epoll_fd = epoll_create1(0);
 405     // getRmrContext(sctpParams);
 406     buildInotify(sctpParams);
 407     buildListeningPort(sctpParams);
 408     sctpParams.sctpMap = new mapWrapper();
 409     listener(&sctpParams);
 410 }
 411
 412 TEST(sctp, TEST12) {
 413     ReportingMessages_t     reporting_msg;
 414     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 415     sendSctpMsg(peerInfo, reporting_msg, sctpMap);
 416 }
 417
 418 /*TEST(sctp, TEST13) {
 419     E2AP_PDU_t              pdu;
 420     Sctp_Map_t              *sctpMap = new Sctp_Map_t();
 421     ReportingMessages_t     message;
 422     RmrMessagesBuffer_t     rmrMessageBuffer;
 423     sctp_params_t           sctp_ut_params;
 424
 425     pdu.present = E2AP_PDU_PR_successfulOutcome;
 426     pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
 427     memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome));
 428     memset( (void*)&message, 0, sizeof(message));
 429     memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer));
 430
 431     message.peerInfo = peerInfo;
 432     message.peerInfo->sctpParams = &sctp_ut_params;
 433     snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
 434
 435     sctp_ut_params.myIP = "1.2.3.4";
 436     sctp_ut_params.rmrPort = 38000;
 437     snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
 438     rmrMessageBuffer.rcvMessage = rmr_rcv_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.rcvMessage);
 439     rmr_get_meid(rmrMessageBuffer.rcvMessage, (unsigned char *)message.message.enodbName);
 440     message.peerInfo = (ConnectedCU_t *) sctpMap->find(message.message.enodbName);
 441     pdu.choice.successfulOutcome->procedureCode = ProcedureCode_id_E2setup;
 442     receiveXappMessages(sctp_ut_params.sctpMap, rmrMessageBuffer, message.message.time);
 443 }*/
 444 int main(int argc, char **argv) {
 445
 446    testing::InitGoogleTest(&argc, argv);
 447    return RUN_ALL_TESTS();
 448
 449 }