X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=RIC-E2-TERMINATION%2FTEST%2Fsctp_thread_test.cpp;fp=RIC-E2-TERMINATION%2FTEST%2Fsctp_thread_test.cpp;h=7b9dbd86376b547426cfbf5bd53a335779498501;hb=f2617ceb3f4ec718c9d161e541b70f060cd0b40d;hp=73655ab073f014f628f79ce12f61453e23700983;hpb=ff4ba622812ab13eb7630c5a54a7719d1b1d0cd4;p=ric-plt%2Fe2.git diff --git a/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp b/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp index 73655ab..7b9dbd8 100644 --- a/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp +++ b/RIC-E2-TERMINATION/TEST/sctp_thread_test.cpp @@ -25,55 +25,83 @@ typedef struct { unsigned char srcip[RMR_MAX_SRC]; // ip address and port of the source } uta_mhdr_t; +constexpr int numberSix = 6; +constexpr int numberSeven = 7; +constexpr int numberEight = 8; +constexpr int numberNine = 9; +constexpr int numberTen = 10; +constexpr int numberEleven = 11; +constexpr int numberTwelve = 12; +constexpr int numberThirteen = 13; +constexpr int numberFourteen = 14; +constexpr int numberFifteen = 15; +constexpr int numberSixteen = 16; +constexpr int numberSeventeen = 17; +constexpr int numberForty = 40; +constexpr int numberHundred = 100; +constexpr int rmrPort = 38000; +constexpr auto dummyIp = "1.2.3.4"; +constexpr int ricRequestorId = 12345; + +extern std::map connectionHandlingPerE2NodeMap; + void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params); +void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer,bool IsRICIndication, bool IsE2SetupReq, bool IsErrorIndication); +void setE2SetupProcedureNotInitiatedToMap(char *enodbName); +void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer); +void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer); +void resetToDefaultValueAsTeardown(char *enodbName) +{ + setE2SetupProcedureNotInitiatedToMap(enodbName); +} TEST(sctp, TEST1) { mdclog_level_set(MDCLOG_DEBUG); string s; - s = translateRmrErrorMessages(0); + s = translateRmrErrorMessages(numberZero); EXPECT_THAT(s, HasSubstr("RMR_OK")); - s = translateRmrErrorMessages(1); + s = translateRmrErrorMessages(numberOne); EXPECT_THAT(s, HasSubstr("RMR_ERR_BADARG")); - s = translateRmrErrorMessages(2); + s = translateRmrErrorMessages(numberTwo); EXPECT_THAT(s, HasSubstr("RMR_ERR_NOENDPT")); - s = translateRmrErrorMessages(3); + s = translateRmrErrorMessages(numberThree); EXPECT_THAT(s, HasSubstr("RMR_ERR_EMPTY")); - s = translateRmrErrorMessages(4); + s = translateRmrErrorMessages(numberFour); EXPECT_THAT(s, HasSubstr("RMR_ERR_NOHDR")); - s = translateRmrErrorMessages(5); + s = translateRmrErrorMessages(numberFive); EXPECT_THAT(s, HasSubstr("RMR_ERR_SENDFAILED")); - s = translateRmrErrorMessages(6); + s = translateRmrErrorMessages(numberSix); EXPECT_THAT(s, HasSubstr("RMR_ERR_CALLFAILED")); - s = translateRmrErrorMessages(7); + s = translateRmrErrorMessages(numberSeven); EXPECT_THAT(s, HasSubstr("RMR_ERR_NOWHOPEN")); - s = translateRmrErrorMessages(8); + s = translateRmrErrorMessages(numberEight); EXPECT_THAT(s, HasSubstr("RMR_ERR_WHID")); - s = translateRmrErrorMessages(9); + s = translateRmrErrorMessages(numberNine); EXPECT_THAT(s, HasSubstr("RMR_ERR_OVERFLOW")); - s = translateRmrErrorMessages(10); + s = translateRmrErrorMessages(numberTen); EXPECT_THAT(s, HasSubstr("RMR_ERR_RETRY")); - s = translateRmrErrorMessages(11); + s = translateRmrErrorMessages(numberEleven); EXPECT_THAT(s, HasSubstr("RMR_ERR_RCVFAILED")); - s = translateRmrErrorMessages(12); + s = translateRmrErrorMessages(numberTwelve); EXPECT_THAT(s, HasSubstr("RMR_ERR_TIMEOUT")); - s = translateRmrErrorMessages(13); + s = translateRmrErrorMessages(numberThirteen); EXPECT_THAT(s, HasSubstr("RMR_ERR_UNSET")); - s = translateRmrErrorMessages(14); + s = translateRmrErrorMessages(numberFourteen); EXPECT_THAT(s, HasSubstr("RMR_ERR_TRUNC")); - s = translateRmrErrorMessages(15); + s = translateRmrErrorMessages(numberFifteen); EXPECT_THAT(s, HasSubstr("RMR_ERR_INITFAILED")); - s = translateRmrErrorMessages(16); + s = translateRmrErrorMessages(numberSixteen); EXPECT_THAT(s, HasSubstr("RMR_ERR_NOTSUPP")); - s = translateRmrErrorMessages(17); + s = translateRmrErrorMessages(numberSeventeen); EXPECT_THAT(s, HasSubstr("UNDOCUMENTED RMR_ERR")); } -auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t)); +auto *peerInfo = (ConnectedCU_t *)calloc(numberOne, sizeof(ConnectedCU_t)); TEST(sctp, TEST2) { struct epoll_event event; event.events = EPOLLIN; - event.data.fd = 0; + event.data.fd = numberZero; ConnectedCU_t data1; ConnectedCU_t *data = &data1; event.data.ptr = (void *)data; @@ -84,12 +112,12 @@ TEST(sctp, TEST2) { handleEinprogressMessages(event,reporting_msg,rmrmessagesbuffer,sctp); } -TEST(sctp, TEST3) { +TEST(sctp, TestSctpAbortThenE2tShouldNotCrash) { struct epoll_event event; event.events = EPOLLIN; - event.data.fd = 0; + event.data.fd = numberZero; ConnectedCU_t data1; - ConnectedCU_t *data = &data1; + ConnectedCU_t *data = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); event.data.ptr = (void *)data; sctp_params_t sctp_ut_params; sctp_params_t* sctp = &sctp_ut_params; @@ -102,10 +130,10 @@ TEST(sctp, TEST3) { TEST(sctp, TEST4) { ConnectedCU_t cu; - ConnectedCU_t* connected_cu = &cu; + ConnectedCU_t* connected_cu1 = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); Sctp_Map_t m1; Sctp_Map_t *m = &m1; - cleanHashEntry(connected_cu,m); + cleanHashEntry(connected_cu1,m); } TEST(sctp, TEST5) { @@ -117,12 +145,24 @@ TEST(sctp, TEST5) { } TEST(sctp, TEST6) { - int epoll_fd = epoll_create1(0); + int epoll_fd = epoll_create1(numberZero); ConnectedCU_t cu; - ConnectedCU_t* peerinfo = &cu; + ConnectedCU_t* peerinfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); Sctp_Map_t m1; Sctp_Map_t *m = &m1; - modifyToEpoll(epoll_fd,peerinfo,2,m, (char*)"enodeb1",2); + modifyToEpoll(epoll_fd,peerinfo,numberTwo,m, (char*)"enodeb1",numberTwo); +} + +TEST(sctp, TEST17) { + sctp_params_t sctpParams; + sctpParams.inotifyFD = negativeOne; + buildInotify(sctpParams); +} + +TEST(sctp, TEST18) { + sctp_params_t sctpParams; + sctpParams.inotifyWD = negativeOne; + buildInotify(sctpParams); } @@ -131,31 +171,78 @@ void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessage message.peerInfo = peerInfo; message.peerInfo->sctpParams = &sctp_ut_params; snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb"); - - sctp_ut_params.myIP = "1.2.3.4"; - sctp_ut_params.rmrPort = 38000; + + sctp_ut_params.myIP = dummyIp; + sctp_ut_params.rmrPort = rmrPort; snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort)); - + rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t)); rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t)); rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA "); rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA"); } -void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) { - +void deleteMemoryForE2SetupReq(E2AP_PDU_t *pdu) +{ + if( (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) && + (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = NULL; + } + if( (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) && + (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]) ) { + free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne] = NULL; + } + if(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) { + free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = NULL; + } + + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = numberZero; + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = numberZero; +} + +void deleteMemoryForRicIndication(E2AP_PDU_t *pdu) +{ if( (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) && - (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]) ) { - free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]); - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = NULL; + (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]); + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero] = NULL; } if(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) { free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array); pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = NULL; } - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 0; - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = 0; - + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = numberZero; + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = numberZero; +} + +void deleteMemoryForErrorIndication(E2AP_PDU_t *pdu) +{ + if( (pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array) && + (pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]); + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero] = NULL; + } + if(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array) { + free(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array); + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array = NULL; + } + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count = numberZero; + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.size = numberZero; +} + +void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer,bool IsRICIndication, bool IsE2SetupReq, bool IsErrorIndication) { + if(IsE2SetupReq){ + deleteMemoryForE2SetupReq(pdu); + } + if(IsRICIndication){ + deleteMemoryForRicIndication(pdu); + } + if(IsErrorIndication){ + deleteMemoryForErrorIndication(pdu); + } if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) { free(rmrMessageBuffer.sendMessage->header); rmrMessageBuffer.sendMessage->header = NULL; @@ -174,6 +261,128 @@ void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmr } } +void create_asnInitiatingReq_Procedure_E2Setup(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2setup */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_E2setup; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest; + + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = (E2setupRequestIEs**) malloc(1 * sizeof(E2setupRequestIEs*)); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = 2; + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = sizeof(E2setupRequestIEs); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs)); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs)); + E2setupRequestIEs_t *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]; + ie->id = ProtocolIE_ID_id_GlobalE2node_ID; + ie->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID; + ie->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB; + + ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]; + ie->id = ProtocolIE_ID_id_TransactionID; + ie->value.present = E2setupRequestIEs__value_PR_TransactionID; + ie->value.choice.TransactionID = numberOne; + + int streamId = numberZero; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, true, false); +} + +void unsupportedRicSubscriptionDelReq(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICsubscriptionDeleteRequired */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICsubscriptionDeleteRequired; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequired; + + int streamId = numberZero; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false); +} + +void unsupportedE2ConnectionUpdateAck(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2connectionUpdate */ + pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_E2connectionUpdate; + pdu->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_E2connectionUpdateAcknowledge; + + asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer); + // delete_memories_successfulOutcome(pdu, rmrMessageBuffer); +} + +void deleteMemoriesForUnsupportedE2ConnectionUpdate(RmrMessagesBuffer_t &rmrMessageBuffer) +{ + if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) { + free(rmrMessageBuffer.sendMessage->header); + rmrMessageBuffer.sendMessage->header = NULL; + } + if(rmrMessageBuffer.sendMessage->payload) { + free(rmrMessageBuffer.sendMessage->payload); + rmrMessageBuffer.sendMessage->payload = NULL; + } + if(rmrMessageBuffer.sendMessage) { + free(rmrMessageBuffer.sendMessage); + rmrMessageBuffer.sendMessage = NULL; + } +} + +void unsupportedE2ConnectionUpdateFail(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2connectionUpdate */ + pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_E2connectionUpdate; + pdu->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcome__value_PR_E2nodeConfigurationUpdateFailure; + + asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer); + + deleteMemoriesForUnsupportedE2ConnectionUpdate(rmrMessageBuffer); +} + +void create_asnInitiatingReq_Procedure_E2SetupWithoutTransactionID(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2setup */ + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_E2setup; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest; + + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = (E2setupRequestIEs**) malloc(1 * sizeof(E2setupRequestIEs*)); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = numberOne; + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = sizeof(E2setupRequestIEs); + pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs)); + E2setupRequestIEs_t *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]; + ie->id = ProtocolIE_ID_id_GlobalE2node_ID; + ie->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID; + ie->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB; + + int streamId = numberZero; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, true, false); +} + void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, @@ -184,10 +393,11 @@ void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu, /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */ pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate; pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate; - - int streamId = 0; + + int streamId = numberZero; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); - delete_memories_initiatingMessage(pdu, rmrMessageBuffer); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false); } void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, @@ -195,23 +405,24 @@ void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) { - + init_memories(message, rmrMessageBuffer, sctp_ut_params); /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */ pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication; pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication; pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*)); - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = 1; + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = numberOne; pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs); - pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs)); - RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[0]; + pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs)); + RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]; ie->id = ProtocolIE_ID_id_RICrequestID; ie->value.present = RICindication_IEs__value_PR_RICrequestID; - ie->value.choice.RICrequestID.ricRequestorID = 12345; - ie->value.choice.RICrequestID.ricInstanceID = 1; - int streamId = 0; + ie->value.choice.RICrequestID.ricRequestorID = ricRequestorId; + ie->value.choice.RICrequestID.ricInstanceID = numberOne; + int streamId = numberZero; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); - delete_memories_initiatingMessage(pdu, rmrMessageBuffer); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,true, false, false); } void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu, @@ -224,9 +435,10 @@ void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu, /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */ pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication; pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication; - int streamId = 0; + int streamId = numberZero; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer, streamId); - delete_memories_initiatingMessage(pdu, rmrMessageBuffer); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false); } void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu, @@ -239,23 +451,56 @@ void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu, /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */ pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset; pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest; - int streamId =0; + int streamId =numberZero; + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId); - delete_memories_initiatingMessage(pdu, rmrMessageBuffer); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false); } -TEST(sctp, TEST7) { +void setE2SetupProcedureNotInitiatedToMap(char *enbName) +{ + printEntryPresentInMap(); + if(connectionHandlingPerE2NodeMap.empty()) + { + mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty"); + return; + } + else + { + mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map"); + std::map::iterator itr = connectionHandlingPerE2NodeMap.begin(); + while(itr != connectionHandlingPerE2NodeMap.end()) + { + mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus); + int result = itr->first.compare(enbName); + if (result == 0) + { + mdclog_write(MDCLOG_DEBUG, "Updating to E2SetupOngoing Procedure"); + itr->second.e2tProcedureOngoingStatus = E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED; + mdclog_write(MDCLOG_DEBUG, "Current procedure updated to %d", itr->second.e2tProcedureOngoingStatus); + itr->second.e2SetupProcedureTransactionId = negativeOne; + break; + } + ++itr; + } + } +} +TEST(sctp, TESTBeforeE2SetupReqThenDropTheMessage) { E2AP_PDU_t pdu; Sctp_Map_t *sctpMap = new Sctp_Map_t(); ReportingMessages_t message; RmrMessagesBuffer_t rmrMessageBuffer; sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; pdu.present = E2AP_PDU_PR_initiatingMessage; pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); - memset( (void*)pdu.choice.initiatingMessage, 0, sizeof(pdu.choice.initiatingMessage)); - memset( (void*)&message, 0, sizeof(message)); - memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); @@ -270,9 +515,10 @@ TEST(sctp, TEST7) { create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); /* For Procedure's Default case. */ pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100); - int streamId =0; + int streamId =numberZero; + asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer,streamId); - + if(pdu.choice.initiatingMessage) { free(pdu.choice.initiatingMessage); pdu.choice.initiatingMessage = NULL; @@ -281,22 +527,24 @@ TEST(sctp, TEST7) { delete sctpMap; sctpMap = NULL; } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); } /* TEST8 Begin: */ void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) { - if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) && - (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]) ) { - free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]); - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = NULL; + if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) && + (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]); + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero] = NULL; } if(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) { free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array); pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = NULL; } - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 0; - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = 0; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = numberZero; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = numberZero; if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) { free(rmrMessageBuffer.sendMessage->header); @@ -333,12 +581,12 @@ void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, sctp_params_t &sctp_ut_params) { init_memories(message, rmrMessageBuffer, sctp_ut_params); - + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*)); - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = 1; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = numberOne; pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t); - pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t)); - RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[0]; + pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t)); + RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]; ie->id = ProtocolIE_ID_id_RICrequestID; ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID; @@ -383,9 +631,9 @@ TEST(sctp, TEST8) { pdu.present = E2AP_PDU_PR_successfulOutcome; pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); - memset( (void*)pdu.choice.successfulOutcome, 0, sizeof(pdu.choice.successfulOutcome)); - memset( (void*)&message, 0, sizeof(message)); - memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1"); @@ -398,9 +646,9 @@ TEST(sctp, TEST8) { /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); /* For Procedure's Default case. */ - pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100); + pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)numberHundred); asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer); - + if(pdu.choice.successfulOutcome) { free(pdu.choice.successfulOutcome); pdu.choice.successfulOutcome = NULL; @@ -415,16 +663,16 @@ TEST(sctp, TEST8) { void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) { if( (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) && - (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]) ) { - free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]); - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = NULL; + (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]) ) { + free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]); + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero] = NULL; } if(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) { free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array); pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = NULL; } - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 0; - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = 0; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = numberZero; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = numberZero; if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) { free(rmrMessageBuffer.sendMessage->header); @@ -447,12 +695,12 @@ void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu, sctp_params_t &sctp_ut_params) { init_memories(message, rmrMessageBuffer, sctp_ut_params); - + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*)); - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = 1; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = numberOne; pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t); - pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t)); - RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[0]; + pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t)); + RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]; ie->id = ProtocolIE_ID_id_RICrequestID; ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID; @@ -480,7 +728,6 @@ void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) { - init_memories(message, rmrMessageBuffer, sctp_ut_params); /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete; @@ -497,9 +744,9 @@ TEST(sctp, TEST9) { pdu.present = E2AP_PDU_PR_unsuccessfulOutcome; pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); - memset( (void*)pdu.choice.unsuccessfulOutcome, 0, sizeof(pdu.choice.unsuccessfulOutcome)); - memset( (void*)&message, 0, sizeof(message)); - memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1"); @@ -510,9 +757,9 @@ TEST(sctp, TEST9) { /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */ create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); /* For Procedure's Default case. */ - pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100); + pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)numberHundred); asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer); - + if(pdu.choice.unsuccessfulOutcome) { free(pdu.choice.unsuccessfulOutcome); pdu.choice.unsuccessfulOutcome = NULL; @@ -525,36 +772,40 @@ TEST(sctp, TEST9) { TEST(sctp, TEST10) { - int epoll_fd = epoll_create1(0); + int epoll_fd = epoll_create1(numberZero); ConnectedCU_t cu; - ConnectedCU_t* peerinfo = &cu; + ConnectedCU_t* peerinfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); Sctp_Map_t m1; Sctp_Map_t *m = &m1; - addToEpoll(epoll_fd, peerinfo, 2, m, (char*)"enodeb1", 0); + addToEpoll(epoll_fd, peerinfo, numberTwo, m, (char*)"enodeb1", numberZero); } TEST(sctp, TEST11) { sctp_params_t sctpParams; int argc = 5; char **argv = (char**) calloc(argc, sizeof(char*)); - argv[0] = (char*) malloc(40 * sizeof(char)); - argv[1] = (char*) malloc(40 * sizeof(char)); - argv[2] = (char*) malloc(40 * sizeof(char)); - argv[3] = (char*) malloc(40 * sizeof(char)); - argv[4] = (char*) malloc(40 * sizeof(char)); - snprintf(argv[0], strlen("./e2 "), "%s", (char*)"./e2"); - snprintf(argv[1], strlen("-p "), "%s", (char*)"-p"); - snprintf(argv[2], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config"); - snprintf(argv[3], strlen("-f "), "%s", (char*)"-f"); - snprintf(argv[4], strlen("config.conf "), "%s", (char*)"config.conf"); - + argv[numberZero] = (char*) malloc(numberForty * sizeof(char)); + argv[numberOne] = (char*) malloc(numberForty * sizeof(char)); + argv[numberTwo] = (char*) malloc(numberForty * sizeof(char)); + argv[numberThree] = (char*) malloc(numberForty * sizeof(char)); + argv[numberFour] = (char*) malloc(numberForty * sizeof(char)); + snprintf(argv[numberZero], strlen("./e2 "), "%s", (char*)"./e2"); + snprintf(argv[numberOne], strlen("-p "), "%s", (char*)"-p"); + snprintf(argv[numberTwo], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config"); + snprintf(argv[numberThree], strlen("-f "), "%s", (char*)"-f"); + snprintf(argv[numberFour], strlen("config.conf "), "%s", (char*)"config.conf"); + auto result = parse(argc, argv, sctpParams); sctpParams.podName.assign("E2TermAlpha_pod"); sctpParams.sctpMap = new mapWrapper(); - sctpParams.epoll_fd = epoll_create1(0); + sctpParams.epoll_fd = epoll_create1(numberZero); buildConfiguration(sctpParams); // getRmrContext(sctpParams); buildInotify(sctpParams); + sctpParams.inotifyFD = negativeOne; + buildInotify(sctpParams); + sctpParams.inotifyWD = negativeOne; + buildInotify(sctpParams); buildListeningPort(sctpParams); listener(&sctpParams); @@ -563,16 +814,16 @@ TEST(sctp, TEST11) { sctpParams.sctpMap = NULL; } if(argv) { - free(argv[0]); - argv[0] = NULL; - free(argv[1]); - argv[1] = NULL; - free(argv[2]); - argv[2] = NULL; - free(argv[3]); - argv[3] = NULL; - free(argv[4]); - argv[4] = NULL; + free(argv[numberZero]); + argv[numberZero] = NULL; + free(argv[numberOne]); + argv[numberOne] = NULL; + free(argv[numberTwo]); + argv[numberTwo] = NULL; + free(argv[numberThree]); + argv[numberThree] = NULL; + free(argv[numberFour]); + argv[numberFour] = NULL; free(argv); argv=NULL; } @@ -741,13 +992,29 @@ void create_receiveXappMessages_RIC_E2_SETUP_RESP(Sctp_Map_t *sctpMap, Reporting delete_memories_rcv(rmrMessageBuffer); } +void create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer) { + inti_buffers_rcv(message, rmrMessageBuffer); + rmrMessageBuffer.rcvMessage->mtype = RIC_E2NODE_CONFIG_UPDATE_ACK; + receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time); + delete_memories_rcv(rmrMessageBuffer); +} + +void create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer) { + inti_buffers_rcv(message, rmrMessageBuffer); + rmrMessageBuffer.rcvMessage->mtype = RIC_E2NODE_CONFIG_UPDATE_FAILURE; + receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time); + delete_memories_rcv(rmrMessageBuffer); +} + TEST(sctp, TEST13) { Sctp_Map_t *sctpMap = new Sctp_Map_t(); ReportingMessages_t message; RmrMessagesBuffer_t rmrMessageBuffer; - memset( (void*)&message, 0, sizeof(message)); - memset( (void*)&rmrMessageBuffer, 0, sizeof(rmrMessageBuffer)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); // Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset create_receiveXappMessages_RIC_E2_SETUP_FAILURE(sctpMap, message, rmrMessageBuffer); @@ -764,6 +1031,8 @@ TEST(sctp, TEST13) { create_receiveXappMessages_RIC_SERVICE_QUERY(sctpMap, message, rmrMessageBuffer); create_receiveXappMessages_RIC_SUB_DEL_REQ(sctpMap, message, rmrMessageBuffer); create_receiveXappMessages_RIC_E2_SETUP_RESP(sctpMap, message, rmrMessageBuffer); + create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_ACK(sctpMap, message, rmrMessageBuffer); + create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer); inti_buffers_rcv(message, rmrMessageBuffer); rmrMessageBuffer.rcvMessage->mtype = 52345; /*Dummy Integer Value for default case*/ @@ -774,95 +1043,822 @@ TEST(sctp, TEST13) { delete sctpMap; sctpMap = NULL; } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); } -/* TEST 14 Begin: */ -void receiveDataFromSctp_asnSuccessfulMsg_Procedure_Default( E2AP_PDU_t *pdu, - RmrMessagesBuffer_t &rmrMessageBuffer) { - pdu->present = E2AP_PDU_PR_successfulOutcome; - pdu->choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); - memset( (void*)pdu->choice.successfulOutcome, 0, sizeof(pdu->choice.successfulOutcome)); - pdu->choice.successfulOutcome->procedureCode = ((ProcedureCode_t)100); - rmrMessageBuffer.sendMessage->tp_buf = pdu; +TEST(sctp, TESTForDebug) { +char* log_level = "4"; +update_mdc_log_level_severity(log_level); } -void delete_pdu_memories(E2AP_PDU_t *pdu) { - if(pdu->choice.successfulOutcome) { - free(pdu->choice.successfulOutcome); - pdu->choice.successfulOutcome = NULL; +TEST(sctp, TestE2SetupRequest) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; } - if(pdu->choice.unsuccessfulOutcome) { - free(pdu->choice.unsuccessfulOutcome); - pdu->choice.unsuccessfulOutcome = NULL; + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; } } -/*void receiveDataFromSctp_asnUnSuccsesfulMsg_Procedure_Default(E2AP_PDU_t *pdu, - RmrMessagesBuffer_t &rmrMessageBuffer) { - pdu->present = E2AP_PDU_PR_unsuccessfulOutcome; - pdu->choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); - memset( (void*)pdu->choice.unsuccessfulOutcome, 0, sizeof(pdu->choice.unsuccessfulOutcome)); - pdu->choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)100); - - rmrMessageBuffer.sendMessage->tp_buf = pdu; -}*/ - -TEST(sctp, TEST14) { +TEST(sctp, TestE2SetupRequestWhenReceivedWithoutTransactionIDThenIgnoreE2SetupProcedure) { E2AP_PDU_t pdu; - struct epoll_event events; - Sctp_Map_t *sctpMap = new Sctp_Map_t(); - int numOfMessages=0; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; RmrMessagesBuffer_t rmrMessageBuffer; - struct timespec ts; - ConnectedCU_t *peerInfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t)); - events.data.ptr = peerInfo; - snprintf(peerInfo->enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb"); + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; - rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t)); - rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t)); - rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA "); - rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA"); + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); - clock_gettime(CLOCK_MONOTONIC, &ts); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); - receiveDataFromSctp_asnSuccessfulMsg_Procedure_Default(&pdu, rmrMessageBuffer); - receiveDataFromSctp(&events, sctpMap, numOfMessages, rmrMessageBuffer, ts); - delete_pdu_memories(&pdu); + create_asnInitiatingReq_Procedure_E2SetupWithoutTransactionID(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); - if(rmrMessageBuffer.sendMessage->payload) { - free(rmrMessageBuffer.sendMessage->payload); - rmrMessageBuffer.sendMessage->payload = NULL; + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; } +} - /*rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA"); - receiveDataFromSctp_asnUnSuccsesfulMsg_Procedure_Default(&pdu, rmrMessageBuffer); - receiveDataFromSctp(&events, sctpMap, numOfMessages, rmrMessageBuffer, ts); - delete_pdu_memories(&pdu); - if(rmrMessageBuffer.sendMessage->payload) { - free(rmrMessageBuffer.sendMessage->payload); - rmrMessageBuffer.sendMessage->payload = NULL; - }*/ - if(rmrMessageBuffer.sendMessage->header) { - free(rmrMessageBuffer.sendMessage->header); - rmrMessageBuffer.sendMessage->header = NULL; +TEST(sctp, TestErrorIndicationWhenE2SetupOngoingProcedureOccurred) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + + create_receiveXappMessages_RIC_E2_SETUP_RESP(sctpMap, message, rmrMessageBuffer); + + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; } - if(rmrMessageBuffer.sendMessage) { - free(rmrMessageBuffer.sendMessage); + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; } - if(peerInfo) { - free(peerInfo); - peerInfo = NULL; +} + + +TEST(sctp, TestE2SetupRequestReceivedThenErrorIndicationMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; } + if(sctpMap) { delete sctpMap; sctpMap = NULL; } } -int main(int argc, char **argv) { +TEST(sctp, TestE2SetupRequestReceivedThenRICindicationMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} +TEST(sctp, TestE2SetupRequestReceivedThenRICserviceUpdateMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenResetMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} +TEST(sctp, TestE2SetupRequestReceivedThenRICcontrolMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICcontrolMessageTriggeredAndGotControlFailure) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionMessageTriggeredAndGotSubsFailure) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionDeleteMessageTriggered) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + resetToDefaultValueAsTeardown(message.message.enodbName); + + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionDeleteMessageTriggeredAndGotSubDelFailure) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + resetToDefaultValueAsTeardown(message.message.enodbName); + + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +void errorIndicationBasedOnProcedureCodeOrProcedureStatus(E2AP_PDU_t *pdu, + Sctp_Map_t *sctpMap, + ReportingMessages_t &message, + RmrMessagesBuffer_t &rmrMessageBuffer, + sctp_params_t &sctp_ut_params) { + + init_memories(message, rmrMessageBuffer, sctp_ut_params); + + pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication; + pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication; + + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array = (ErrorIndication_IEs**) malloc(1 * sizeof(ErrorIndication_IEs*)); + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count = 1; + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.size = sizeof(ErrorIndication_IEs); + pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero] = (ErrorIndication_IEs*) malloc(sizeof(ErrorIndication_IEs)); + + ErrorIndication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]; + + ie->id = ProtocolIE_ID_id_TransactionID; + ie->criticality = Criticality_reject; + ie->value.present = ErrorIndication_IEs__value_PR_TransactionID; + ie->value.choice.TransactionID = numberThree; + + int streamId = numberZero; + + asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer, streamId); + delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, true); +} + +TEST(sctp, TestDropErrorIndicationReceivedWithInvalidTidWhenE2SetupOngoingProcedureOccurredBasedOnOngoingProcedureStatus) { + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + E2AP_PDU_t pdu; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + errorIndicationBasedOnProcedureCodeOrProcedureStatus(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestRemovalOfE2ConnectionEntryFromMap) { + + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + removeE2ConnectionEntryFromMap(message.message.enodbName); + + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } +} + +TEST(sctp, TestUnsupportedRicSubsDelRequiredBeforeE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + unsupportedRicSubscriptionDelReq(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestUnsupportedRicSubsDelRequiredAfterE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + unsupportedRicSubscriptionDelReq(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestUnsupportedE2ConnectionUpdateAckBeforeE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); + memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + unsupportedE2ConnectionUpdateAck(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.successfulOutcome) { + free(pdu.choice.successfulOutcome); + pdu.choice.successfulOutcome = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestUnsupportedE2ConnectionUpdateAckAfterE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome)); + memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome)); + + unsupportedE2ConnectionUpdateAck(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(pdu.choice.successfulOutcome) { + free(pdu.choice.successfulOutcome); + pdu.choice.successfulOutcome = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + +} + +TEST(sctp, TestUnsupportedE2ConnectionUpdateFailBeforeE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); + memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + unsupportedE2ConnectionUpdateFail(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.unsuccessfulOutcome) { + free(pdu.choice.unsuccessfulOutcome); + pdu.choice.unsuccessfulOutcome = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestUnsupportedE2ConnectionUpdateFailAfterE2SetupReqThenE2TShouldNotCrash) { + E2AP_PDU_t pdu; + Sctp_Map_t *sctpMap = new Sctp_Map_t(); + ReportingMessages_t message; + RmrMessagesBuffer_t rmrMessageBuffer; + sctp_params_t sctp_ut_params; + struct E2NodeConnectionHandling e2NodeConnectionHandling; + memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling)); + e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED; + e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne; + + pdu.present = E2AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage)); + memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage)); + memset( (void*)&message, numberZero, sizeof(message)); + memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer)); + + snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560"); + rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01); + + create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome)); + memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome)); + + unsupportedE2ConnectionUpdateFail(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params); + + if(pdu.choice.initiatingMessage) { + free(pdu.choice.initiatingMessage); + pdu.choice.initiatingMessage = NULL; + } + if(pdu.choice.unsuccessfulOutcome) { + free(pdu.choice.unsuccessfulOutcome); + pdu.choice.unsuccessfulOutcome = NULL; + } + if(sctpMap) { + delete sctpMap; + sctpMap = NULL; + } + resetToDefaultValueAsTeardown(message.message.enodbName); + ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED); +} + +TEST(sctp, TestForInfo) { +char* log_level = "3"; +update_mdc_log_level_severity(log_level); +} + +TEST(sctp, TestForWarn) { +char* log_level = "2"; +update_mdc_log_level_severity(log_level); +} + +TEST(sctp, TestForErr) { +char* log_level = "1"; +update_mdc_log_level_severity(log_level); +} + +int main(int argc, char **argv) { + + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); }