1 #include <gtest/gtest.h>
2 #include <gmock/gmock.h>
3 #include "sctpThread.h"
7 using namespace testing;
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)
25 unsigned char srcip[RMR_MAX_SRC]; // ip address and port of the source
28 constexpr int numberSix = 6;
29 constexpr int numberSeven = 7;
30 constexpr int numberEight = 8;
31 constexpr int numberNine = 9;
32 constexpr int numberTen = 10;
33 constexpr int numberEleven = 11;
34 constexpr int numberTwelve = 12;
35 constexpr int numberThirteen = 13;
36 constexpr int numberFourteen = 14;
37 constexpr int numberFifteen = 15;
38 constexpr int numberSixteen = 16;
39 constexpr int numberSeventeen = 17;
40 constexpr int numberForty = 40;
41 constexpr int numberHundred = 100;
42 constexpr int rmrPort = 38000;
43 constexpr auto dummyIp = "1.2.3.4";
44 constexpr int ricRequestorId = 12345;
46 extern std::map<std::string, E2NodeConnectionHandling> connectionHandlingPerE2NodeMap;
48 void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params);
49 void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer,bool IsRICIndication, bool IsE2SetupReq, bool IsErrorIndication);
50 void setE2SetupProcedureNotInitiatedToMap(char *enodbName);
51 void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer);
52 void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer);
53 void resetToDefaultValueAsTeardown(char *enodbName)
55 setE2SetupProcedureNotInitiatedToMap(enodbName);
59 mdclog_level_set(MDCLOG_DEBUG);
61 s = translateRmrErrorMessages(numberZero);
62 EXPECT_THAT(s, HasSubstr("RMR_OK"));
63 s = translateRmrErrorMessages(numberOne);
64 EXPECT_THAT(s, HasSubstr("RMR_ERR_BADARG"));
65 s = translateRmrErrorMessages(numberTwo);
66 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOENDPT"));
67 s = translateRmrErrorMessages(numberThree);
68 EXPECT_THAT(s, HasSubstr("RMR_ERR_EMPTY"));
69 s = translateRmrErrorMessages(numberFour);
70 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOHDR"));
71 s = translateRmrErrorMessages(numberFive);
72 EXPECT_THAT(s, HasSubstr("RMR_ERR_SENDFAILED"));
73 s = translateRmrErrorMessages(numberSix);
74 EXPECT_THAT(s, HasSubstr("RMR_ERR_CALLFAILED"));
75 s = translateRmrErrorMessages(numberSeven);
76 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOWHOPEN"));
77 s = translateRmrErrorMessages(numberEight);
78 EXPECT_THAT(s, HasSubstr("RMR_ERR_WHID"));
79 s = translateRmrErrorMessages(numberNine);
80 EXPECT_THAT(s, HasSubstr("RMR_ERR_OVERFLOW"));
81 s = translateRmrErrorMessages(numberTen);
82 EXPECT_THAT(s, HasSubstr("RMR_ERR_RETRY"));
83 s = translateRmrErrorMessages(numberEleven);
84 EXPECT_THAT(s, HasSubstr("RMR_ERR_RCVFAILED"));
85 s = translateRmrErrorMessages(numberTwelve);
86 EXPECT_THAT(s, HasSubstr("RMR_ERR_TIMEOUT"));
87 s = translateRmrErrorMessages(numberThirteen);
88 EXPECT_THAT(s, HasSubstr("RMR_ERR_UNSET"));
89 s = translateRmrErrorMessages(numberFourteen);
90 EXPECT_THAT(s, HasSubstr("RMR_ERR_TRUNC"));
91 s = translateRmrErrorMessages(numberFifteen);
92 EXPECT_THAT(s, HasSubstr("RMR_ERR_INITFAILED"));
93 s = translateRmrErrorMessages(numberSixteen);
94 EXPECT_THAT(s, HasSubstr("RMR_ERR_NOTSUPP"));
95 s = translateRmrErrorMessages(numberSeventeen);
96 EXPECT_THAT(s, HasSubstr("UNDOCUMENTED RMR_ERR"));
99 auto *peerInfo = (ConnectedCU_t *)calloc(numberOne, sizeof(ConnectedCU_t));
102 struct epoll_event event;
103 event.events = EPOLLIN;
104 event.data.fd = numberZero;
106 ConnectedCU_t *data = &data1;
107 event.data.ptr = (void *)data;
108 sctp_params_t sctp_ut_params;
109 sctp_params_t* sctp = &sctp_ut_params;
110 ReportingMessages_t reporting_msg;
111 RmrMessagesBuffer_t rmrmessagesbuffer;
112 handleEinprogressMessages(event,reporting_msg,rmrmessagesbuffer,sctp);
115 TEST(sctp, TestSctpAbortThenE2tShouldNotCrash) {
116 struct epoll_event event;
117 event.events = EPOLLIN;
118 event.data.fd = numberZero;
120 ConnectedCU_t *data = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
121 event.data.ptr = (void *)data;
122 sctp_params_t sctp_ut_params;
123 sctp_params_t* sctp = &sctp_ut_params;
125 sctp ->sctpMap = &m1;
126 ReportingMessages_t reporting_msg;
127 RmrMessagesBuffer_t rmrmessagesbuffer;
128 handlepoll_error(event,reporting_msg,rmrmessagesbuffer,sctp);
133 ConnectedCU_t* connected_cu1 = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
136 cleanHashEntry(connected_cu1,m);
140 sctp_params_t sctp_ut_params;
141 sctp_params_t* sctp = &sctp_ut_params;
142 sctp->configFilePath.assign("/opt/e2/RIC-E2-TERMINATION/config");
143 sctp->configFileName.assign("config.conf");
144 handleConfigChange(sctp);
148 int epoll_fd = epoll_create1(numberZero);
150 ConnectedCU_t* peerinfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
153 modifyToEpoll(epoll_fd,peerinfo,numberTwo,m, (char*)"enodeb1",numberTwo);
157 sctp_params_t sctpParams;
158 sctpParams.inotifyFD = negativeOne;
159 buildInotify(sctpParams);
163 sctp_params_t sctpParams;
164 sctpParams.inotifyWD = negativeOne;
165 buildInotify(sctpParams);
170 void init_memories(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, sctp_params_t &sctp_ut_params) {
171 message.peerInfo = peerInfo;
172 message.peerInfo->sctpParams = &sctp_ut_params;
173 snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
175 sctp_ut_params.myIP = dummyIp;
176 sctp_ut_params.rmrPort = rmrPort;
177 snprintf(sctp_ut_params.rmrAddress, sizeof(sctp_ut_params.rmrAddress), "%d", (int) (sctp_ut_params.rmrPort));
179 rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
180 rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
181 rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from NOKIA ");
182 rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from NOKIA");
185 void deleteMemoryForE2SetupReq(E2AP_PDU_t *pdu)
187 if( (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) &&
188 (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]) ) {
189 free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero]);
190 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = NULL;
192 if( (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) &&
193 (pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]) ) {
194 free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne]);
195 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne] = NULL;
197 if(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array) {
198 free(pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array);
199 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = NULL;
202 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = numberZero;
203 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = numberZero;
206 void deleteMemoryForRicIndication(E2AP_PDU_t *pdu)
208 if( (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) &&
209 (pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]) ) {
210 free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero]);
211 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero] = NULL;
213 if(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array) {
214 free(pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array);
215 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = NULL;
217 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = numberZero;
218 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = numberZero;
221 void deleteMemoryForErrorIndication(E2AP_PDU_t *pdu)
223 if( (pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array) &&
224 (pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]) ) {
225 free(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero]);
226 pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero] = NULL;
228 if(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array) {
229 free(pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array);
230 pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array = NULL;
232 pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count = numberZero;
233 pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.size = numberZero;
236 void delete_memories_initiatingMessage(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer,bool IsRICIndication, bool IsE2SetupReq, bool IsErrorIndication) {
238 deleteMemoryForE2SetupReq(pdu);
241 deleteMemoryForRicIndication(pdu);
243 if(IsErrorIndication){
244 deleteMemoryForErrorIndication(pdu);
246 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
247 free(rmrMessageBuffer.sendMessage->header);
248 rmrMessageBuffer.sendMessage->header = NULL;
250 if(rmrMessageBuffer.sendMessage->payload) {
251 free(rmrMessageBuffer.sendMessage->payload);
252 rmrMessageBuffer.sendMessage->payload = NULL;
254 if(rmrMessageBuffer.sendMessage) {
255 free(rmrMessageBuffer.sendMessage);
256 rmrMessageBuffer.sendMessage = NULL;
258 if(rmrMessageBuffer.rmrCtx) {
259 rmr_close(rmrMessageBuffer.rmrCtx);
260 rmrMessageBuffer.rmrCtx = NULL;
264 void create_asnInitiatingReq_Procedure_E2Setup(E2AP_PDU_t *pdu,
266 ReportingMessages_t &message,
267 RmrMessagesBuffer_t &rmrMessageBuffer,
268 sctp_params_t &sctp_ut_params) {
270 init_memories(message, rmrMessageBuffer, sctp_ut_params);
271 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2setup */
272 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_E2setup;
273 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest;
275 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = (E2setupRequestIEs**) malloc(1 * sizeof(E2setupRequestIEs*));
276 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = 2;
277 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = sizeof(E2setupRequestIEs);
278 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs));
279 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs));
280 E2setupRequestIEs_t *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero];
281 ie->id = ProtocolIE_ID_id_GlobalE2node_ID;
282 ie->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
283 ie->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
285 ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberOne];
286 ie->id = ProtocolIE_ID_id_TransactionID;
287 ie->value.present = E2setupRequestIEs__value_PR_TransactionID;
288 ie->value.choice.TransactionID = numberOne;
290 int streamId = numberZero;
292 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
293 delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, true, false);
296 void unsupportedRicSubscriptionDelReq(E2AP_PDU_t *pdu,
298 ReportingMessages_t &message,
299 RmrMessagesBuffer_t &rmrMessageBuffer,
300 sctp_params_t &sctp_ut_params) {
302 init_memories(message, rmrMessageBuffer, sctp_ut_params);
303 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICsubscriptionDeleteRequired */
304 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICsubscriptionDeleteRequired;
305 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequired;
307 int streamId = numberZero;
309 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
310 delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false);
313 void unsupportedE2ConnectionUpdateAck(E2AP_PDU_t *pdu,
315 ReportingMessages_t &message,
316 RmrMessagesBuffer_t &rmrMessageBuffer,
317 sctp_params_t &sctp_ut_params) {
319 init_memories(message, rmrMessageBuffer, sctp_ut_params);
320 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2connectionUpdate */
321 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_E2connectionUpdate;
322 pdu->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_E2connectionUpdateAcknowledge;
324 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
325 // delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
328 void deleteMemoriesForUnsupportedE2ConnectionUpdate(RmrMessagesBuffer_t &rmrMessageBuffer)
330 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
331 free(rmrMessageBuffer.sendMessage->header);
332 rmrMessageBuffer.sendMessage->header = NULL;
334 if(rmrMessageBuffer.sendMessage->payload) {
335 free(rmrMessageBuffer.sendMessage->payload);
336 rmrMessageBuffer.sendMessage->payload = NULL;
338 if(rmrMessageBuffer.sendMessage) {
339 free(rmrMessageBuffer.sendMessage);
340 rmrMessageBuffer.sendMessage = NULL;
344 void unsupportedE2ConnectionUpdateFail(E2AP_PDU_t *pdu,
346 ReportingMessages_t &message,
347 RmrMessagesBuffer_t &rmrMessageBuffer,
348 sctp_params_t &sctp_ut_params) {
350 init_memories(message, rmrMessageBuffer, sctp_ut_params);
351 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2connectionUpdate */
352 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_E2connectionUpdate;
353 pdu->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcome__value_PR_E2nodeConfigurationUpdateFailure;
355 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
357 deleteMemoriesForUnsupportedE2ConnectionUpdate(rmrMessageBuffer);
360 void create_asnInitiatingReq_Procedure_E2SetupWithoutTransactionID(E2AP_PDU_t *pdu,
362 ReportingMessages_t &message,
363 RmrMessagesBuffer_t &rmrMessageBuffer,
364 sctp_params_t &sctp_ut_params) {
366 init_memories(message, rmrMessageBuffer, sctp_ut_params);
367 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_E2setup */
368 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_E2setup;
369 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest;
371 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array = (E2setupRequestIEs**) malloc(1 * sizeof(E2setupRequestIEs*));
372 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.count = numberOne;
373 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.size = sizeof(E2setupRequestIEs);
374 pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero] = (E2setupRequestIEs*) malloc(sizeof(E2setupRequestIEs));
375 E2setupRequestIEs_t *ie = pdu->choice.initiatingMessage->value.choice.E2setupRequest.protocolIEs.list.array[numberZero];
376 ie->id = ProtocolIE_ID_id_GlobalE2node_ID;
377 ie->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
378 ie->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
380 int streamId = numberZero;
382 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
383 delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, true, false);
386 void create_asnInitiatingReq_Procedure_RICserviceUpdate(E2AP_PDU_t *pdu,
388 ReportingMessages_t &message,
389 RmrMessagesBuffer_t &rmrMessageBuffer,
390 sctp_params_t &sctp_ut_params) {
392 init_memories(message, rmrMessageBuffer, sctp_ut_params);
393 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
394 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate;
395 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate;
397 int streamId = numberZero;
399 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
400 delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false);
403 void create_asnInitiatingReq_Procedure_RICindication(E2AP_PDU_t *pdu,
405 ReportingMessages_t &message,
406 RmrMessagesBuffer_t &rmrMessageBuffer,
407 sctp_params_t &sctp_ut_params) {
409 init_memories(message, rmrMessageBuffer, sctp_ut_params);
410 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
411 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_RICindication;
412 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RICindication;
413 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array = (RICindication_IEs**) malloc(1 * sizeof(RICindication_IEs*));
414 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.count = numberOne;
415 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.size = sizeof(RICindication_IEs);
416 pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero] = (RICindication_IEs*) malloc(sizeof(RICindication_IEs));
417 RICindication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.RICindication.protocolIEs.list.array[numberZero];
418 ie->id = ProtocolIE_ID_id_RICrequestID;
419 ie->value.present = RICindication_IEs__value_PR_RICrequestID;
420 ie->value.choice.RICrequestID.ricRequestorID = ricRequestorId;
421 ie->value.choice.RICrequestID.ricInstanceID = numberOne;
422 int streamId = numberZero;
424 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
425 delete_memories_initiatingMessage(pdu, rmrMessageBuffer,true, false, false);
428 void create_asnInitiatingReq_Procedure_ErrorIndication(E2AP_PDU_t *pdu,
430 ReportingMessages_t &message,
431 RmrMessagesBuffer_t &rmrMessageBuffer,
432 sctp_params_t &sctp_ut_params) {
434 init_memories(message, rmrMessageBuffer, sctp_ut_params);
435 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
436 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication;
437 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication;
438 int streamId = numberZero;
440 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer, streamId);
441 delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false);
444 void create_asnInitiatingReq_Procedure_Reset(E2AP_PDU_t *pdu,
446 ReportingMessages_t &message,
447 RmrMessagesBuffer_t &rmrMessageBuffer,
448 sctp_params_t &sctp_ut_params) {
450 init_memories(message, rmrMessageBuffer, sctp_ut_params);
451 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
452 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
453 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest;
454 int streamId =numberZero;
456 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer,streamId);
457 delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, false);
460 void setE2SetupProcedureNotInitiatedToMap(char *enbName)
462 printEntryPresentInMap();
463 if(connectionHandlingPerE2NodeMap.empty())
465 mdclog_write(MDCLOG_DEBUG, "connectionHandlingPerE2Node map is empty");
470 mdclog_write(MDCLOG_DEBUG, "Entry Present in connectionHandlingPerE2NodeMap Map");
471 std::map<std::string, E2NodeConnectionHandling>::iterator itr = connectionHandlingPerE2NodeMap.begin();
472 while(itr != connectionHandlingPerE2NodeMap.end())
474 mdclog_write(MDCLOG_DEBUG, "Key %s Found in connectionHandlingPerE2NodeMap Map, Current Procedure is %d", enbName, itr->second.e2tProcedureOngoingStatus);
475 int result = itr->first.compare(enbName);
478 mdclog_write(MDCLOG_DEBUG, "Updating to E2SetupOngoing Procedure");
479 itr->second.e2tProcedureOngoingStatus = E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED;
480 mdclog_write(MDCLOG_DEBUG, "Current procedure updated to %d", itr->second.e2tProcedureOngoingStatus);
481 itr->second.e2SetupProcedureTransactionId = negativeOne;
488 TEST(sctp, TESTBeforeE2SetupReqThenDropTheMessage) {
490 Sctp_Map_t *sctpMap = new Sctp_Map_t();
491 ReportingMessages_t message;
492 RmrMessagesBuffer_t rmrMessageBuffer;
493 sctp_params_t sctp_ut_params;
494 struct E2NodeConnectionHandling e2NodeConnectionHandling;
495 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
496 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
497 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
499 pdu.present = E2AP_PDU_PR_initiatingMessage;
500 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
501 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
502 memset( (void*)&message, numberZero, sizeof(message));
503 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
505 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
506 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
508 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICserviceUpdate */
509 create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
510 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_RICindication */
511 create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
512 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_ErrorIndication */
513 create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
514 /* Sending E2AP_PDU_PR_initiatingMessage and procedure code as: ProcedureCode_id_Reset */
515 create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
516 /* For Procedure's Default case. */
517 pdu.choice.initiatingMessage->procedureCode = ((ProcedureCode_t)100);
518 int streamId =numberZero;
520 asnInitiatingRequest(&pdu, sctpMap, message, rmrMessageBuffer,streamId);
522 if(pdu.choice.initiatingMessage) {
523 free(pdu.choice.initiatingMessage);
524 pdu.choice.initiatingMessage = NULL;
530 resetToDefaultValueAsTeardown(message.message.enodbName);
531 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
535 void delete_memories_successfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
537 if( (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) &&
538 (pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]) ) {
539 free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero]);
540 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero] = NULL;
542 if(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array) {
543 free(pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array);
544 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = NULL;
546 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = numberZero;
547 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = numberZero;
549 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
550 free(rmrMessageBuffer.sendMessage->header);
551 rmrMessageBuffer.sendMessage->header = NULL;
553 if(rmrMessageBuffer.sendMessage->payload) {
554 free(rmrMessageBuffer.sendMessage->payload);
555 rmrMessageBuffer.sendMessage->payload = NULL;
557 if(rmrMessageBuffer.sendMessage) {
558 free(rmrMessageBuffer.sendMessage);
559 rmrMessageBuffer.sendMessage = NULL;
564 void create_asnSuccessfulMsg_Procedure_Reset(E2AP_PDU_t *pdu,
566 ReportingMessages_t &message,
567 RmrMessagesBuffer_t &rmrMessageBuffer,
568 sctp_params_t &sctp_ut_params) {
570 init_memories(message, rmrMessageBuffer, sctp_ut_params);
571 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
572 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
573 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
574 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
577 void create_asnSuccessfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
579 ReportingMessages_t &message,
580 RmrMessagesBuffer_t &rmrMessageBuffer,
581 sctp_params_t &sctp_ut_params) {
583 init_memories(message, rmrMessageBuffer, sctp_ut_params);
585 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array = (RICcontrolAcknowledge_IEs_t**) malloc(1 * sizeof(RICcontrolAcknowledge_IEs_t*));
586 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.count = numberOne;
587 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.size = sizeof(RICcontrolAcknowledge_IEs_t);
588 pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero] = (RICcontrolAcknowledge_IEs_t*) malloc(sizeof(RICcontrolAcknowledge_IEs_t));
589 RICcontrolAcknowledge_IEs_t *ie = pdu->choice.successfulOutcome->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[numberZero];
591 ie->id = ProtocolIE_ID_id_RICrequestID;
592 ie->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID;
593 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
594 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
595 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
596 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
599 void create_asnSuccessfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
601 ReportingMessages_t &message,
602 RmrMessagesBuffer_t &rmrMessageBuffer,
603 sctp_params_t &sctp_ut_params) {
605 init_memories(message, rmrMessageBuffer, sctp_ut_params);
606 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
607 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
608 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
609 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
612 void create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
614 ReportingMessages_t &message,
615 RmrMessagesBuffer_t &rmrMessageBuffer,
616 sctp_params_t &sctp_ut_params) {
618 init_memories(message, rmrMessageBuffer, sctp_ut_params);
619 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
620 pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
621 asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
622 delete_memories_successfulOutcome(pdu, rmrMessageBuffer);
627 Sctp_Map_t *sctpMap = new Sctp_Map_t();
628 ReportingMessages_t message;
629 RmrMessagesBuffer_t rmrMessageBuffer;
630 sctp_params_t sctp_ut_params;
632 pdu.present = E2AP_PDU_PR_successfulOutcome;
633 pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
634 memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome));
635 memset( (void*)&message, numberZero, sizeof(message));
636 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
638 snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
640 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset */
641 create_asnSuccessfulMsg_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
642 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
643 create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
644 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
645 create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
646 /* Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
647 create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
648 /* For Procedure's Default case. */
649 pdu.choice.successfulOutcome->procedureCode = ((ProcedureCode_t)numberHundred);
650 asnSuccessfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
652 if(pdu.choice.successfulOutcome) {
653 free(pdu.choice.successfulOutcome);
654 pdu.choice.successfulOutcome = NULL;
663 void delete_memories_unsuccessfulOutcome(E2AP_PDU_t *pdu, RmrMessagesBuffer_t &rmrMessageBuffer) {
665 if( (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) &&
666 (pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]) ) {
667 free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero]);
668 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero] = NULL;
670 if(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array) {
671 free(pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array);
672 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = NULL;
674 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = numberZero;
675 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = numberZero;
677 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
678 free(rmrMessageBuffer.sendMessage->header);
679 rmrMessageBuffer.sendMessage->header = NULL;
681 if(rmrMessageBuffer.sendMessage->payload) {
682 free(rmrMessageBuffer.sendMessage->payload);
683 rmrMessageBuffer.sendMessage->payload = NULL;
685 if(rmrMessageBuffer.sendMessage) {
686 free(rmrMessageBuffer.sendMessage);
687 rmrMessageBuffer.sendMessage = NULL;
691 void create_asnUnSuccsesfulMsg_Procedure_RICcontrol(E2AP_PDU_t *pdu,
693 ReportingMessages_t &message,
694 RmrMessagesBuffer_t &rmrMessageBuffer,
695 sctp_params_t &sctp_ut_params) {
697 init_memories(message, rmrMessageBuffer, sctp_ut_params);
699 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array = (RICcontrolFailure_IEs_t**) malloc(1*sizeof(RICcontrolFailure_IEs_t*));
700 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.count = numberOne;
701 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.size = sizeof(RICcontrolFailure_IEs_t);
702 pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero] = (RICcontrolFailure_IEs_t*) malloc(sizeof(RICcontrolFailure_IEs_t));
703 RICcontrolFailure_IEs_t *ie = pdu->choice.unsuccessfulOutcome->value.choice.RICcontrolFailure.protocolIEs.list.array[numberZero];
705 ie->id = ProtocolIE_ID_id_RICrequestID;
706 ie->value.present = RICcontrolFailure_IEs__value_PR_RICrequestID;
707 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
708 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICcontrol;
709 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
710 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
713 void create_asnUnSuccsesfulMsg_Procedure_RICsubscription(E2AP_PDU_t *pdu,
715 ReportingMessages_t &message,
716 RmrMessagesBuffer_t &rmrMessageBuffer,
717 sctp_params_t &sctp_ut_params) {
719 init_memories(message, rmrMessageBuffer, sctp_ut_params);
720 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
721 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscription;
722 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
723 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
726 void create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(E2AP_PDU_t *pdu,
728 ReportingMessages_t &message,
729 RmrMessagesBuffer_t &rmrMessageBuffer,
730 sctp_params_t &sctp_ut_params) {
731 init_memories(message, rmrMessageBuffer, sctp_ut_params);
732 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
733 pdu->choice.unsuccessfulOutcome->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
734 asnUnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer);
735 delete_memories_unsuccessfulOutcome(pdu, rmrMessageBuffer);
740 Sctp_Map_t *sctpMap = new Sctp_Map_t();
741 ReportingMessages_t message;
742 RmrMessagesBuffer_t rmrMessageBuffer;
743 sctp_params_t sctp_ut_params;
745 pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
746 pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
747 memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome));
748 memset( (void*)&message, numberZero, sizeof(message));
749 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
751 snprintf(sctp_ut_params.rmrAddress, strlen("127.0.0.1 "), "%s", (char*)"127.0.0.1");
753 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICcontrol */
754 create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
755 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscription */
756 create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
757 /* Sending E2AP_PDU_PR_unsuccessfulOutcome and procedure code as: ProcedureCode_id_RICsubscriptionDelete */
758 create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
759 /* For Procedure's Default case. */
760 pdu.choice.unsuccessfulOutcome->procedureCode = ((ProcedureCode_t)numberHundred);
761 asnUnSuccsesfulMsg(&pdu, sctpMap, message, rmrMessageBuffer);
763 if(pdu.choice.unsuccessfulOutcome) {
764 free(pdu.choice.unsuccessfulOutcome);
765 pdu.choice.unsuccessfulOutcome = NULL;
775 int epoll_fd = epoll_create1(numberZero);
777 ConnectedCU_t* peerinfo = (ConnectedCU_t *) calloc(1, sizeof(ConnectedCU_t));
780 addToEpoll(epoll_fd, peerinfo, numberTwo, m, (char*)"enodeb1", numberZero);
784 sctp_params_t sctpParams;
786 char **argv = (char**) calloc(argc, sizeof(char*));
787 argv[numberZero] = (char*) malloc(numberForty * sizeof(char));
788 argv[numberOne] = (char*) malloc(numberForty * sizeof(char));
789 argv[numberTwo] = (char*) malloc(numberForty * sizeof(char));
790 argv[numberThree] = (char*) malloc(numberForty * sizeof(char));
791 argv[numberFour] = (char*) malloc(numberForty * sizeof(char));
792 snprintf(argv[numberZero], strlen("./e2 "), "%s", (char*)"./e2");
793 snprintf(argv[numberOne], strlen("-p "), "%s", (char*)"-p");
794 snprintf(argv[numberTwo], strlen("/opt/e2/RIC-E2-TERMINATION/config "), "%s", (char*)"/opt/e2/RIC-E2-TERMINATION/config");
795 snprintf(argv[numberThree], strlen("-f "), "%s", (char*)"-f");
796 snprintf(argv[numberFour], strlen("config.conf "), "%s", (char*)"config.conf");
798 auto result = parse(argc, argv, sctpParams);
799 sctpParams.podName.assign("E2TermAlpha_pod");
800 sctpParams.sctpMap = new mapWrapper();
801 sctpParams.epoll_fd = epoll_create1(numberZero);
802 buildConfiguration(sctpParams);
803 // getRmrContext(sctpParams);
804 buildInotify(sctpParams);
805 sctpParams.inotifyFD = negativeOne;
806 buildInotify(sctpParams);
807 sctpParams.inotifyWD = negativeOne;
808 buildInotify(sctpParams);
809 buildListeningPort(sctpParams);
810 listener(&sctpParams);
812 if(sctpParams.sctpMap) {
813 delete sctpParams.sctpMap;
814 sctpParams.sctpMap = NULL;
817 free(argv[numberZero]);
818 argv[numberZero] = NULL;
819 free(argv[numberOne]);
820 argv[numberOne] = NULL;
821 free(argv[numberTwo]);
822 argv[numberTwo] = NULL;
823 free(argv[numberThree]);
824 argv[numberThree] = NULL;
825 free(argv[numberFour]);
826 argv[numberFour] = NULL;
833 ReportingMessages_t reporting_msg;
834 Sctp_Map_t *sctpMap = new Sctp_Map_t();
835 sendSctpMsg(peerInfo, reporting_msg, sctpMap);
845 void inti_buffers_rcv(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) {
846 message.peerInfo = peerInfo;
847 snprintf(message.message.enodbName, strlen("Nokia_enb "), "%s", (char*)"Nokia_enb");
849 rmrMessageBuffer.rcvMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
850 rmrMessageBuffer.rcvMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
851 rmrMessageBuffer.rcvMessage->len = strlen("Saying Hello from Ramji ");
852 rmrMessageBuffer.rcvMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
854 rmrMessageBuffer.sendMessage = (rmr_mbuf_t*) malloc(sizeof(rmr_mbuf_t));
855 rmrMessageBuffer.sendMessage->header = (uta_mhdr_t*) malloc(sizeof(uta_mhdr_t));
856 rmrMessageBuffer.sendMessage->len = strlen("Saying Hello from Ramji ");
857 rmrMessageBuffer.sendMessage->payload = (unsigned char*)strdup("Saying Hello from Ramji");
861 void delete_memories_rcv(RmrMessagesBuffer_t &rmrMessageBuffer) {
863 if(rmrMessageBuffer.rcvMessage && rmrMessageBuffer.rcvMessage->header) {
864 free(rmrMessageBuffer.rcvMessage->header);
865 rmrMessageBuffer.rcvMessage->header = NULL;
867 if(rmrMessageBuffer.rcvMessage) {
868 free(rmrMessageBuffer.rcvMessage);
869 rmrMessageBuffer.rcvMessage = NULL;
871 if(rmrMessageBuffer.sendMessage && rmrMessageBuffer.sendMessage->header) {
872 free(rmrMessageBuffer.sendMessage->header);
873 rmrMessageBuffer.sendMessage->header = NULL;
875 if(rmrMessageBuffer.sendMessage) {
876 free(rmrMessageBuffer.sendMessage);
877 rmrMessageBuffer.sendMessage = NULL;
882 void create_receiveXappMessages_RIC_ERROR_INDICATION(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
883 RmrMessagesBuffer_t &rmrMessageBuffer) {
884 inti_buffers_rcv(message, rmrMessageBuffer);
885 rmrMessageBuffer.rcvMessage->mtype = RIC_ERROR_INDICATION;
886 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
887 delete_memories_rcv(rmrMessageBuffer);
890 void create_receiveXappMessages_RIC_E2_SETUP_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
891 RmrMessagesBuffer_t &rmrMessageBuffer) {
892 inti_buffers_rcv(message, rmrMessageBuffer);
893 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_SETUP_FAILURE;
894 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
895 delete_memories_rcv(rmrMessageBuffer);
898 void create_receiveXappMessages_RIC_SUB_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
899 RmrMessagesBuffer_t &rmrMessageBuffer) {
900 inti_buffers_rcv(message, rmrMessageBuffer);
901 rmrMessageBuffer.rcvMessage->mtype = RIC_SUB_REQ;
902 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
903 delete_memories_rcv(rmrMessageBuffer);
906 void create_receiveXappMessages_RIC_CONTROL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
907 RmrMessagesBuffer_t &rmrMessageBuffer) {
908 inti_buffers_rcv(message, rmrMessageBuffer);
909 rmrMessageBuffer.rcvMessage->mtype = RIC_CONTROL_REQ;
910 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
911 delete_memories_rcv(rmrMessageBuffer);
914 void create_receiveXappMessages_RIC_SERVICE_QUERY(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
915 RmrMessagesBuffer_t &rmrMessageBuffer) {
916 inti_buffers_rcv(message, rmrMessageBuffer);
917 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_QUERY;
918 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
919 delete_memories_rcv(rmrMessageBuffer);
922 void create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
923 RmrMessagesBuffer_t &rmrMessageBuffer) {
924 inti_buffers_rcv(message, rmrMessageBuffer);
925 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_ACK;
926 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
927 delete_memories_rcv(rmrMessageBuffer);
930 void create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
931 RmrMessagesBuffer_t &rmrMessageBuffer) {
932 inti_buffers_rcv(message, rmrMessageBuffer);
933 rmrMessageBuffer.rcvMessage->mtype = RIC_SERVICE_UPDATE_FAILURE;
934 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
935 delete_memories_rcv(rmrMessageBuffer);
939 void create_receiveXappMessages_RIC_E2_RESET_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
940 RmrMessagesBuffer_t &rmrMessageBuffer) {
941 inti_buffers_rcv(message, rmrMessageBuffer);
942 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_REQ;
943 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
944 delete_memories_rcv(rmrMessageBuffer);
947 void create_receiveXappMessages_RIC_E2_RESET_RESP(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
948 RmrMessagesBuffer_t &rmrMessageBuffer) {
949 inti_buffers_rcv(message, rmrMessageBuffer);
950 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_RESET_RESP;
951 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
952 delete_memories_rcv(rmrMessageBuffer);
955 void create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
956 RmrMessagesBuffer_t &rmrMessageBuffer) {
957 inti_buffers_rcv(message, rmrMessageBuffer);
958 rmrMessageBuffer.rcvMessage->mtype = RIC_SCTP_CLEAR_ALL;
959 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
960 delete_memories_rcv(rmrMessageBuffer);
963 void create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
964 RmrMessagesBuffer_t &rmrMessageBuffer) {
965 inti_buffers_rcv(message, rmrMessageBuffer);
966 rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_REQ;
967 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
968 delete_memories_rcv(rmrMessageBuffer);
971 void create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
972 RmrMessagesBuffer_t &rmrMessageBuffer) {
973 inti_buffers_rcv(message, rmrMessageBuffer);
974 rmrMessageBuffer.rcvMessage->mtype = E2_TERM_KEEP_ALIVE_REQ;
975 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
976 delete_memories_rcv(rmrMessageBuffer);
979 void create_receiveXappMessages_RIC_SUB_DEL_REQ(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
980 RmrMessagesBuffer_t &rmrMessageBuffer) {
981 inti_buffers_rcv(message, rmrMessageBuffer);
982 rmrMessageBuffer.rcvMessage->mtype = RIC_SUB_DEL_REQ;
983 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
984 delete_memories_rcv(rmrMessageBuffer);
987 void create_receiveXappMessages_RIC_E2_SETUP_RESP(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
988 RmrMessagesBuffer_t &rmrMessageBuffer) {
989 inti_buffers_rcv(message, rmrMessageBuffer);
990 rmrMessageBuffer.rcvMessage->mtype = RIC_E2_SETUP_RESP;
991 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
992 delete_memories_rcv(rmrMessageBuffer);
995 void create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_ACK(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
996 RmrMessagesBuffer_t &rmrMessageBuffer) {
997 inti_buffers_rcv(message, rmrMessageBuffer);
998 rmrMessageBuffer.rcvMessage->mtype = RIC_E2NODE_CONFIG_UPDATE_ACK;
999 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
1000 delete_memories_rcv(rmrMessageBuffer);
1003 void create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_FAILURE(Sctp_Map_t *sctpMap, ReportingMessages_t &message,
1004 RmrMessagesBuffer_t &rmrMessageBuffer) {
1005 inti_buffers_rcv(message, rmrMessageBuffer);
1006 rmrMessageBuffer.rcvMessage->mtype = RIC_E2NODE_CONFIG_UPDATE_FAILURE;
1007 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
1008 delete_memories_rcv(rmrMessageBuffer);
1011 TEST(sctp, TEST13) {
1012 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1013 ReportingMessages_t message;
1014 RmrMessagesBuffer_t rmrMessageBuffer;
1016 memset( (void*)&message, numberZero, sizeof(message));
1017 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1019 // Sending E2AP_PDU_PR_successfulOutcome and procedure code as: ProcedureCode_id_Reset
1020 create_receiveXappMessages_RIC_E2_SETUP_FAILURE(sctpMap, message, rmrMessageBuffer);
1021 create_receiveXappMessages_RIC_ERROR_INDICATION(sctpMap, message, rmrMessageBuffer);
1022 create_receiveXappMessages_RIC_SUB_REQ(sctpMap, message, rmrMessageBuffer);
1023 create_receiveXappMessages_RIC_CONTROL_REQ(sctpMap, message, rmrMessageBuffer);
1024 create_receiveXappMessages_RIC_HEALTH_CHECK_REQ(sctpMap, message, rmrMessageBuffer);
1025 create_receiveXappMessages_E2_TERM_KEEP_ALIVE_REQ(sctpMap, message, rmrMessageBuffer);
1026 create_receiveXappMessages_RIC_SCTP_CLEAR_ALL(sctpMap, message, rmrMessageBuffer);
1027 create_receiveXappMessages_RIC_E2_RESET_RESP(sctpMap, message, rmrMessageBuffer);
1028 create_receiveXappMessages_RIC_E2_RESET_REQ(sctpMap, message, rmrMessageBuffer);
1029 create_receiveXappMessages_RIC_SERVICE_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer);
1030 create_receiveXappMessages_RIC_SERVICE_UPDATE_ACK(sctpMap, message, rmrMessageBuffer);
1031 create_receiveXappMessages_RIC_SERVICE_QUERY(sctpMap, message, rmrMessageBuffer);
1032 create_receiveXappMessages_RIC_SUB_DEL_REQ(sctpMap, message, rmrMessageBuffer);
1033 create_receiveXappMessages_RIC_E2_SETUP_RESP(sctpMap, message, rmrMessageBuffer);
1034 create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_ACK(sctpMap, message, rmrMessageBuffer);
1035 create_receiveXappMessages_RIC_E2NODE_CONFIG_UPDATE_FAILURE(sctpMap, message, rmrMessageBuffer);
1037 inti_buffers_rcv(message, rmrMessageBuffer);
1038 rmrMessageBuffer.rcvMessage->mtype = 52345; /*Dummy Integer Value for default case*/
1039 receiveXappMessages(sctpMap, rmrMessageBuffer, message.message.time);
1040 delete_memories_rcv(rmrMessageBuffer);
1046 resetToDefaultValueAsTeardown(message.message.enodbName);
1047 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1050 TEST(sctp, TESTForDebug) {
1051 char* log_level = "4";
1052 update_mdc_log_level_severity(log_level);
1055 TEST(sctp, TestE2SetupRequest) {
1057 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1058 ReportingMessages_t message;
1059 RmrMessagesBuffer_t rmrMessageBuffer;
1060 sctp_params_t sctp_ut_params;
1062 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1063 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1064 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1065 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1067 pdu.present = E2AP_PDU_PR_initiatingMessage;
1068 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1069 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1070 memset( (void*)&message, numberZero, sizeof(message));
1071 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1073 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1074 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1076 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1078 resetToDefaultValueAsTeardown(message.message.enodbName);
1079 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1081 if(pdu.choice.initiatingMessage) {
1082 free(pdu.choice.initiatingMessage);
1083 pdu.choice.initiatingMessage = NULL;
1091 TEST(sctp, TestE2SetupRequestWhenReceivedWithoutTransactionIDThenIgnoreE2SetupProcedure) {
1093 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1094 ReportingMessages_t message;
1095 RmrMessagesBuffer_t rmrMessageBuffer;
1096 sctp_params_t sctp_ut_params;
1097 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1098 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1099 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1100 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1102 pdu.present = E2AP_PDU_PR_initiatingMessage;
1103 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1104 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1105 memset( (void*)&message, numberZero, sizeof(message));
1106 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1108 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1109 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1111 create_asnInitiatingReq_Procedure_E2SetupWithoutTransactionID(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1113 resetToDefaultValueAsTeardown(message.message.enodbName);
1114 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1116 if(pdu.choice.initiatingMessage) {
1117 free(pdu.choice.initiatingMessage);
1118 pdu.choice.initiatingMessage = NULL;
1127 TEST(sctp, TestErrorIndicationWhenE2SetupOngoingProcedureOccurred) {
1128 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1129 ReportingMessages_t message;
1130 RmrMessagesBuffer_t rmrMessageBuffer;
1132 sctp_params_t sctp_ut_params;
1133 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1134 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1135 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1136 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1138 pdu.present = E2AP_PDU_PR_initiatingMessage;
1139 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1140 memset( (void*)&message, numberZero, sizeof(message));
1141 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1142 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1144 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1146 create_receiveXappMessages_RIC_E2_SETUP_RESP(sctpMap, message, rmrMessageBuffer);
1148 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1150 create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1151 resetToDefaultValueAsTeardown(message.message.enodbName);
1152 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1154 if(pdu.choice.initiatingMessage) {
1155 free(pdu.choice.initiatingMessage);
1156 pdu.choice.initiatingMessage = NULL;
1166 TEST(sctp, TestE2SetupRequestReceivedThenErrorIndicationMessageTriggered) {
1167 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1168 ReportingMessages_t message;
1169 RmrMessagesBuffer_t rmrMessageBuffer;
1171 sctp_params_t sctp_ut_params;
1172 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1173 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1174 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1175 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1177 pdu.present = E2AP_PDU_PR_initiatingMessage;
1178 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1179 memset( (void*)&message, numberZero, sizeof(message));
1180 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1181 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1182 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1183 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1184 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1186 create_asnInitiatingReq_Procedure_ErrorIndication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1188 resetToDefaultValueAsTeardown(message.message.enodbName);
1189 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1191 if(pdu.choice.initiatingMessage) {
1192 free(pdu.choice.initiatingMessage);
1193 pdu.choice.initiatingMessage = NULL;
1202 TEST(sctp, TestE2SetupRequestReceivedThenRICindicationMessageTriggered) {
1203 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1204 ReportingMessages_t message;
1205 RmrMessagesBuffer_t rmrMessageBuffer;
1207 sctp_params_t sctp_ut_params;
1208 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1209 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1210 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1211 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1213 pdu.present = E2AP_PDU_PR_initiatingMessage;
1214 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1215 memset( (void*)&message, numberZero, sizeof(message));
1216 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1217 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1218 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1219 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1220 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1222 create_asnInitiatingReq_Procedure_RICindication(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1224 resetToDefaultValueAsTeardown(message.message.enodbName);
1225 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1227 if(pdu.choice.initiatingMessage) {
1228 free(pdu.choice.initiatingMessage);
1229 pdu.choice.initiatingMessage = NULL;
1237 TEST(sctp, TestE2SetupRequestReceivedThenRICserviceUpdateMessageTriggered) {
1238 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1239 ReportingMessages_t message;
1240 RmrMessagesBuffer_t rmrMessageBuffer;
1242 sctp_params_t sctp_ut_params;
1243 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1244 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1245 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1246 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1248 pdu.present = E2AP_PDU_PR_initiatingMessage;
1249 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1250 memset( (void*)&message, numberZero, sizeof(message));
1251 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1252 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1253 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1254 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1255 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1257 create_asnInitiatingReq_Procedure_RICserviceUpdate(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1259 resetToDefaultValueAsTeardown(message.message.enodbName);
1260 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1262 if(pdu.choice.initiatingMessage) {
1263 free(pdu.choice.initiatingMessage);
1264 pdu.choice.initiatingMessage = NULL;
1273 TEST(sctp, TestE2SetupRequestReceivedThenResetMessageTriggered) {
1274 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1275 ReportingMessages_t message;
1276 RmrMessagesBuffer_t rmrMessageBuffer;
1278 sctp_params_t sctp_ut_params;
1279 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1280 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1281 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1282 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1284 pdu.present = E2AP_PDU_PR_initiatingMessage;
1285 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1286 memset( (void*)&message, numberZero, sizeof(message));
1287 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1288 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1289 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1290 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1291 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1293 create_asnInitiatingReq_Procedure_Reset(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1295 resetToDefaultValueAsTeardown(message.message.enodbName);
1296 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1298 if(pdu.choice.initiatingMessage) {
1299 free(pdu.choice.initiatingMessage);
1300 pdu.choice.initiatingMessage = NULL;
1308 TEST(sctp, TestE2SetupRequestReceivedThenRICcontrolMessageTriggered) {
1309 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1310 ReportingMessages_t message;
1311 RmrMessagesBuffer_t rmrMessageBuffer;
1313 sctp_params_t sctp_ut_params;
1314 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1315 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1316 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1317 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1319 pdu.present = E2AP_PDU_PR_initiatingMessage;
1320 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1321 memset( (void*)&message, numberZero, sizeof(message));
1322 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1323 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1324 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1325 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1326 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1328 create_asnSuccessfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1330 resetToDefaultValueAsTeardown(message.message.enodbName);
1331 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1333 if(pdu.choice.initiatingMessage) {
1334 free(pdu.choice.initiatingMessage);
1335 pdu.choice.initiatingMessage = NULL;
1344 TEST(sctp, TestE2SetupRequestReceivedThenRICcontrolMessageTriggeredAndGotControlFailure) {
1345 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1346 ReportingMessages_t message;
1347 RmrMessagesBuffer_t rmrMessageBuffer;
1349 sctp_params_t sctp_ut_params;
1350 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1351 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1352 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1353 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1355 pdu.present = E2AP_PDU_PR_initiatingMessage;
1356 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1357 memset( (void*)&message, numberZero, sizeof(message));
1358 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1359 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1360 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1361 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1362 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1364 create_asnUnSuccsesfulMsg_Procedure_RICcontrol(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1366 resetToDefaultValueAsTeardown(message.message.enodbName);
1367 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1369 if(pdu.choice.initiatingMessage) {
1370 free(pdu.choice.initiatingMessage);
1371 pdu.choice.initiatingMessage = NULL;
1380 TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionMessageTriggered) {
1381 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1382 ReportingMessages_t message;
1383 RmrMessagesBuffer_t rmrMessageBuffer;
1385 sctp_params_t sctp_ut_params;
1386 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1387 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1388 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1389 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1391 pdu.present = E2AP_PDU_PR_initiatingMessage;
1392 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1393 memset( (void*)&message, numberZero, sizeof(message));
1394 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1395 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1396 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1397 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1398 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1400 create_asnSuccessfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1402 resetToDefaultValueAsTeardown(message.message.enodbName);
1403 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1405 if(pdu.choice.initiatingMessage) {
1406 free(pdu.choice.initiatingMessage);
1407 pdu.choice.initiatingMessage = NULL;
1416 TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionMessageTriggeredAndGotSubsFailure) {
1417 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1418 ReportingMessages_t message;
1419 RmrMessagesBuffer_t rmrMessageBuffer;
1421 sctp_params_t sctp_ut_params;
1422 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1423 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1424 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1425 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1427 pdu.present = E2AP_PDU_PR_initiatingMessage;
1428 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1429 memset( (void*)&message, numberZero, sizeof(message));
1430 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1431 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1432 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1433 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1434 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1436 create_asnUnSuccsesfulMsg_Procedure_RICsubscription(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1438 resetToDefaultValueAsTeardown(message.message.enodbName);
1439 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1441 if(pdu.choice.initiatingMessage) {
1442 free(pdu.choice.initiatingMessage);
1443 pdu.choice.initiatingMessage = NULL;
1452 TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionDeleteMessageTriggered) {
1453 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1454 ReportingMessages_t message;
1455 RmrMessagesBuffer_t rmrMessageBuffer;
1457 sctp_params_t sctp_ut_params;
1458 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1459 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1460 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1461 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1463 pdu.present = E2AP_PDU_PR_initiatingMessage;
1464 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1465 memset( (void*)&message, numberZero, sizeof(message));
1466 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1467 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1468 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1469 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1470 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1472 create_asnSuccessfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1473 resetToDefaultValueAsTeardown(message.message.enodbName);
1475 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1477 if(pdu.choice.initiatingMessage) {
1478 free(pdu.choice.initiatingMessage);
1479 pdu.choice.initiatingMessage = NULL;
1488 TEST(sctp, TestE2SetupRequestReceivedThenRICsubscriptionDeleteMessageTriggeredAndGotSubDelFailure) {
1489 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1490 ReportingMessages_t message;
1491 RmrMessagesBuffer_t rmrMessageBuffer;
1493 sctp_params_t sctp_ut_params;
1494 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1495 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1496 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1497 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1499 pdu.present = E2AP_PDU_PR_initiatingMessage;
1500 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1501 memset( (void*)&message, numberZero, sizeof(message));
1502 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1503 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1504 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1505 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1506 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1508 create_asnUnSuccsesfulMsg_Procedure_RICsubscriptionDelete(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1509 resetToDefaultValueAsTeardown(message.message.enodbName);
1511 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1513 if(pdu.choice.initiatingMessage) {
1514 free(pdu.choice.initiatingMessage);
1515 pdu.choice.initiatingMessage = NULL;
1524 void errorIndicationBasedOnProcedureCodeOrProcedureStatus(E2AP_PDU_t *pdu,
1525 Sctp_Map_t *sctpMap,
1526 ReportingMessages_t &message,
1527 RmrMessagesBuffer_t &rmrMessageBuffer,
1528 sctp_params_t &sctp_ut_params) {
1530 init_memories(message, rmrMessageBuffer, sctp_ut_params);
1532 pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_ErrorIndication;
1533 pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ErrorIndication;
1535 pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array = (ErrorIndication_IEs**) malloc(1 * sizeof(ErrorIndication_IEs*));
1536 pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.count = 1;
1537 pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.size = sizeof(ErrorIndication_IEs);
1538 pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero] = (ErrorIndication_IEs*) malloc(sizeof(ErrorIndication_IEs));
1540 ErrorIndication_IEs_t *ie = pdu->choice.initiatingMessage->value.choice.ErrorIndication.protocolIEs.list.array[numberZero];
1542 ie->id = ProtocolIE_ID_id_TransactionID;
1543 ie->criticality = Criticality_reject;
1544 ie->value.present = ErrorIndication_IEs__value_PR_TransactionID;
1545 ie->value.choice.TransactionID = numberThree;
1547 int streamId = numberZero;
1549 asnInitiatingRequest(pdu, sctpMap, message, rmrMessageBuffer, streamId);
1550 delete_memories_initiatingMessage(pdu, rmrMessageBuffer,false, false, true);
1553 TEST(sctp, TestDropErrorIndicationReceivedWithInvalidTidWhenE2SetupOngoingProcedureOccurredBasedOnOngoingProcedureStatus) {
1554 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1555 ReportingMessages_t message;
1556 RmrMessagesBuffer_t rmrMessageBuffer;
1558 sctp_params_t sctp_ut_params;
1559 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1560 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1561 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1562 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1564 pdu.present = E2AP_PDU_PR_initiatingMessage;
1565 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1566 memset( (void*)&message, numberZero, sizeof(message));
1567 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1568 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1569 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1570 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1571 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1573 errorIndicationBasedOnProcedureCodeOrProcedureStatus(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1575 resetToDefaultValueAsTeardown(message.message.enodbName);
1576 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1578 if(pdu.choice.initiatingMessage) {
1579 free(pdu.choice.initiatingMessage);
1580 pdu.choice.initiatingMessage = NULL;
1589 TEST(sctp, TestRemovalOfE2ConnectionEntryFromMap) {
1592 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1593 ReportingMessages_t message;
1594 RmrMessagesBuffer_t rmrMessageBuffer;
1595 sctp_params_t sctp_ut_params;
1597 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1598 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1599 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1600 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1602 pdu.present = E2AP_PDU_PR_initiatingMessage;
1603 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1604 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1605 memset( (void*)&message, numberZero, sizeof(message));
1606 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1608 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1609 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1611 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1613 removeE2ConnectionEntryFromMap(message.message.enodbName);
1615 resetToDefaultValueAsTeardown(message.message.enodbName);
1616 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1618 if(pdu.choice.initiatingMessage) {
1619 free(pdu.choice.initiatingMessage);
1620 pdu.choice.initiatingMessage = NULL;
1628 TEST(sctp, TestUnsupportedRicSubsDelRequiredBeforeE2SetupReqThenE2TShouldNotCrash) {
1630 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1631 ReportingMessages_t message;
1632 RmrMessagesBuffer_t rmrMessageBuffer;
1633 sctp_params_t sctp_ut_params;
1634 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1635 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1636 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1637 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1639 pdu.present = E2AP_PDU_PR_initiatingMessage;
1640 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1641 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1642 memset( (void*)&message, numberZero, sizeof(message));
1643 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1645 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1646 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1648 unsupportedRicSubscriptionDelReq(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1650 if(pdu.choice.initiatingMessage) {
1651 free(pdu.choice.initiatingMessage);
1652 pdu.choice.initiatingMessage = NULL;
1658 resetToDefaultValueAsTeardown(message.message.enodbName);
1659 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1662 TEST(sctp, TestUnsupportedRicSubsDelRequiredAfterE2SetupReqThenE2TShouldNotCrash) {
1664 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1665 ReportingMessages_t message;
1666 RmrMessagesBuffer_t rmrMessageBuffer;
1667 sctp_params_t sctp_ut_params;
1668 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1669 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1670 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1671 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1673 pdu.present = E2AP_PDU_PR_initiatingMessage;
1674 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1675 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1676 memset( (void*)&message, numberZero, sizeof(message));
1677 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1679 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1680 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1682 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1684 unsupportedRicSubscriptionDelReq(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1686 if(pdu.choice.initiatingMessage) {
1687 free(pdu.choice.initiatingMessage);
1688 pdu.choice.initiatingMessage = NULL;
1694 resetToDefaultValueAsTeardown(message.message.enodbName);
1695 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1698 TEST(sctp, TestUnsupportedE2ConnectionUpdateAckBeforeE2SetupReqThenE2TShouldNotCrash) {
1700 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1701 ReportingMessages_t message;
1702 RmrMessagesBuffer_t rmrMessageBuffer;
1703 sctp_params_t sctp_ut_params;
1705 pdu.present = E2AP_PDU_PR_initiatingMessage;
1706 pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
1707 memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome));
1708 memset( (void*)&message, numberZero, sizeof(message));
1709 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1711 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1712 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1714 unsupportedE2ConnectionUpdateAck(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1716 if(pdu.choice.successfulOutcome) {
1717 free(pdu.choice.successfulOutcome);
1718 pdu.choice.successfulOutcome = NULL;
1724 resetToDefaultValueAsTeardown(message.message.enodbName);
1725 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1728 TEST(sctp, TestUnsupportedE2ConnectionUpdateAckAfterE2SetupReqThenE2TShouldNotCrash) {
1730 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1731 ReportingMessages_t message;
1732 RmrMessagesBuffer_t rmrMessageBuffer;
1733 sctp_params_t sctp_ut_params;
1734 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1735 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1736 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1737 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1739 pdu.present = E2AP_PDU_PR_initiatingMessage;
1740 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1741 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1742 memset( (void*)&message, numberZero, sizeof(message));
1743 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1745 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1746 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1748 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1750 pdu.choice.successfulOutcome = (SuccessfulOutcome*) malloc(sizeof(SuccessfulOutcome));
1751 memset( (void*)pdu.choice.successfulOutcome, numberZero, sizeof(pdu.choice.successfulOutcome));
1753 unsupportedE2ConnectionUpdateAck(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1754 resetToDefaultValueAsTeardown(message.message.enodbName);
1755 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1757 if(pdu.choice.initiatingMessage) {
1758 free(pdu.choice.initiatingMessage);
1759 pdu.choice.initiatingMessage = NULL;
1761 if(pdu.choice.successfulOutcome) {
1762 free(pdu.choice.successfulOutcome);
1763 pdu.choice.successfulOutcome = NULL;
1772 TEST(sctp, TestUnsupportedE2ConnectionUpdateFailBeforeE2SetupReqThenE2TShouldNotCrash) {
1774 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1775 ReportingMessages_t message;
1776 RmrMessagesBuffer_t rmrMessageBuffer;
1777 sctp_params_t sctp_ut_params;
1779 pdu.present = E2AP_PDU_PR_initiatingMessage;
1780 pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
1781 memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome));
1782 memset( (void*)&message, numberZero, sizeof(message));
1783 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1785 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1786 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1788 unsupportedE2ConnectionUpdateFail(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1790 if(pdu.choice.unsuccessfulOutcome) {
1791 free(pdu.choice.unsuccessfulOutcome);
1792 pdu.choice.unsuccessfulOutcome = NULL;
1798 resetToDefaultValueAsTeardown(message.message.enodbName);
1799 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1802 TEST(sctp, TestUnsupportedE2ConnectionUpdateFailAfterE2SetupReqThenE2TShouldNotCrash) {
1804 Sctp_Map_t *sctpMap = new Sctp_Map_t();
1805 ReportingMessages_t message;
1806 RmrMessagesBuffer_t rmrMessageBuffer;
1807 sctp_params_t sctp_ut_params;
1808 struct E2NodeConnectionHandling e2NodeConnectionHandling;
1809 memset(&e2NodeConnectionHandling, numberZero, sizeof(e2NodeConnectionHandling));
1810 e2NodeConnectionHandling.e2tProcedureOngoingStatus = E2_SETUP_PROCEDURE_NOT_INITIATED;
1811 e2NodeConnectionHandling.e2SetupProcedureTransactionId = numberOne;
1813 pdu.present = E2AP_PDU_PR_initiatingMessage;
1814 pdu.choice.initiatingMessage = (InitiatingMessage*) malloc(sizeof(InitiatingMessage));
1815 memset( (void*)pdu.choice.initiatingMessage, numberZero, sizeof(pdu.choice.initiatingMessage));
1816 memset( (void*)&message, numberZero, sizeof(message));
1817 memset( (void*)&rmrMessageBuffer, numberZero, sizeof(rmrMessageBuffer));
1819 snprintf(sctp_ut_params.rmrAddress, strlen("tcp:4560 "), "%s", (char*)"tcp:4560");
1820 rmrMessageBuffer.rmrCtx = rmr_init(sctp_ut_params.rmrAddress, RECEIVE_XAPP_BUFFER_SIZE, 0x01);
1822 create_asnInitiatingReq_Procedure_E2Setup(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1824 pdu.choice.unsuccessfulOutcome = (UnsuccessfulOutcome*) malloc(sizeof(UnsuccessfulOutcome));
1825 memset( (void*)pdu.choice.unsuccessfulOutcome, numberZero, sizeof(pdu.choice.unsuccessfulOutcome));
1827 unsupportedE2ConnectionUpdateFail(&pdu, sctpMap, message, rmrMessageBuffer, sctp_ut_params);
1829 if(pdu.choice.initiatingMessage) {
1830 free(pdu.choice.initiatingMessage);
1831 pdu.choice.initiatingMessage = NULL;
1833 if(pdu.choice.unsuccessfulOutcome) {
1834 free(pdu.choice.unsuccessfulOutcome);
1835 pdu.choice.unsuccessfulOutcome = NULL;
1841 resetToDefaultValueAsTeardown(message.message.enodbName);
1842 ASSERT_TRUE(currentE2tProcedureOngoingStatus(message.message.enodbName) == E2T_Procedure_States::E2_SETUP_PROCEDURE_NOT_INITIATED);
1845 TEST(sctp, TestForInfo) {
1846 char* log_level = "3";
1847 update_mdc_log_level_severity(log_level);
1850 TEST(sctp, TestForWarn) {
1851 char* log_level = "2";
1852 update_mdc_log_level_severity(log_level);
1855 TEST(sctp, TestForErr) {
1856 char* log_level = "1";
1857 update_mdc_log_level_severity(log_level);
1860 int main(int argc, char **argv) {
1862 testing::InitGoogleTest(&argc, argv);
1863 return RUN_ALL_TESTS();