2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
23 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
24 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
25 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
26 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
31 //-----------------------------------------------------------------------------
33 //-----------------------------------------------------------------------------
34 var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
36 //-----------------------------------------------------------------------------
38 //-----------------------------------------------------------------------------
39 func (xappConn *testingXappControl) handle_xapp_subs_req(t *testing.T, oldTrans *xappTransaction) *xappTransaction {
40 xapp.Logger.Info("(%s) handle_xapp_subs_req", xappConn.desc)
41 e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
43 //---------------------------------
44 // xapp activity: Send Subs Req
45 //---------------------------------
46 xapp.Logger.Info("(%s) Send Subs Req", xappConn.desc)
48 req := &e2ap.E2APSubscriptionRequest{}
54 req.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true
55 req.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150")
56 req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 123
57 req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDHomeBits28
59 // gnb -> enb outgoing
60 // enb -> gnb incoming
62 req.EventTriggerDefinition.InterfaceDirection = e2ap.E2AP_InterfaceDirectionIncoming
63 req.EventTriggerDefinition.ProcedureCode = 5 //28 35
64 req.EventTriggerDefinition.TypeOfMessage = e2ap.E2AP_InitiatingMessage
66 req.ActionSetups = make([]e2ap.ActionToBeSetupItem, 1)
67 req.ActionSetups[0].ActionId = 0
68 req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeReport
69 req.ActionSetups[0].ActionDefinition.Present = false
70 //req.ActionSetups[index].ActionDefinition.StyleId = 255
71 //req.ActionSetups[index].ActionDefinition.ParamId = 222
72 req.ActionSetups[0].SubsequentAction.Present = true
73 req.ActionSetups[0].SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue
74 req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitZero
77 xapp.Logger.Debug("%s", e2SubsReq.String())
78 err, packedMsg := e2SubsReq.Pack(nil)
80 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
84 var trans *xappTransaction = oldTrans
86 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
89 params := &RMRParams{&xapp.RMRParams{}}
90 params.Mtype = xapp.RIC_SUB_REQ
92 params.Payload = packedMsg.Buf
93 params.Meid = trans.meid
94 params.Xid = trans.xid
97 snderr := xappConn.RmrSend(params)
99 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
105 //-----------------------------------------------------------------------------
107 //-----------------------------------------------------------------------------
108 func (xappConn *testingXappControl) handle_xapp_subs_resp(t *testing.T, trans *xappTransaction) int {
109 xapp.Logger.Info("(%s) handle_xapp_subs_resp", xappConn.desc)
110 e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
113 //---------------------------------
114 // xapp activity: Recv Subs Resp
115 //---------------------------------
117 case msg := <-xappConn.rmrConChan:
118 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] {
119 testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype])
121 } else if msg.Xid != trans.xid {
122 testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
125 packedData := &packer.PackedData{}
126 packedData.Buf = msg.Payload
128 unpackerr := e2SubsResp.UnPack(packedData)
130 if unpackerr != nil {
131 testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
133 geterr, resp := e2SubsResp.Get()
135 testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error())
138 xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
141 case <-time.After(15 * time.Second):
142 testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc)
148 //-----------------------------------------------------------------------------
150 //-----------------------------------------------------------------------------
151 func (xappConn *testingXappControl) handle_xapp_subs_fail(t *testing.T, trans *xappTransaction) int {
152 xapp.Logger.Info("(%s) handle_xapp_subs_fail", xappConn.desc)
153 e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
156 //-------------------------------
157 // xapp activity: Recv Subs Fail
158 //-------------------------------
160 case msg := <-xappConn.rmrConChan:
161 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] {
162 testError(t, "(%s) Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype])
164 } else if msg.Xid != trans.xid {
165 testError(t, "(%s) Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
168 packedData := &packer.PackedData{}
169 packedData.Buf = msg.Payload
171 unpackerr := e2SubsFail.UnPack(packedData)
173 if unpackerr != nil {
174 testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.desc, unpackerr.Error())
176 geterr, resp := e2SubsFail.Get()
178 testError(t, "(%s) RIC_SUB_FAILURE get failed err: %s", xappConn.desc, geterr.Error())
181 xapp.Logger.Info("(%s) Recv Subs Fail rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
184 case <-time.After(15 * time.Second):
185 testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.desc)
191 //-----------------------------------------------------------------------------
193 //-----------------------------------------------------------------------------
194 func (xappConn *testingXappControl) handle_xapp_subs_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId int) *xappTransaction {
195 xapp.Logger.Info("(%s) handle_xapp_subs_del_req", xappConn.desc)
196 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
198 //---------------------------------
199 // xapp activity: Send Subs Del Req
200 //---------------------------------
201 xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
203 req := &e2ap.E2APSubscriptionDeleteRequest{}
205 req.RequestId.Seq = uint32(e2SubsId)
208 e2SubsDelReq.Set(req)
209 xapp.Logger.Debug("%s", e2SubsDelReq.String())
210 err, packedMsg := e2SubsDelReq.Pack(nil)
212 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
216 var trans *xappTransaction = oldTrans
218 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
221 params := &RMRParams{&xapp.RMRParams{}}
222 params.Mtype = xapp.RIC_SUB_DEL_REQ
223 params.SubId = e2SubsId
224 params.Payload = packedMsg.Buf
225 params.Meid = trans.meid
226 params.Xid = trans.xid
229 snderr := xappConn.RmrSend(params)
231 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
237 //-----------------------------------------------------------------------------
239 //-----------------------------------------------------------------------------
240 func (xappConn *testingXappControl) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) {
241 xapp.Logger.Info("(%s) handle_xapp_subs_del_resp", xappConn.desc)
242 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
244 //---------------------------------
245 // xapp activity: Recv Subs Del Resp
246 //---------------------------------
248 case msg := <-xappConn.rmrConChan:
249 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
250 testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype])
252 } else if msg.Xid != trans.xid {
253 testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
256 packedData := &packer.PackedData{}
257 packedData.Buf = msg.Payload
258 unpackerr := e2SubsDelResp.UnPack(packedData)
259 if unpackerr != nil {
260 testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
262 geterr, resp := e2SubsDelResp.Get()
264 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
266 xapp.Logger.Info("(%s) Recv Subs Del Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
269 case <-time.After(15 * time.Second):
270 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
274 //-----------------------------------------------------------------------------
276 //-----------------------------------------------------------------------------
277 func (e2termConn *testingE2termControl) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *RMRParams) {
278 xapp.Logger.Info("(%s) handle_e2term_subs_req", e2termConn.desc)
279 e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
281 //---------------------------------
282 // e2term activity: Recv Subs Req
283 //---------------------------------
285 case msg := <-e2termConn.rmrConChan:
286 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
287 testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
289 xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc)
290 packedData := &packer.PackedData{}
291 packedData.Buf = msg.Payload
292 unpackerr := e2SubsReq.UnPack(packedData)
293 if unpackerr != nil {
294 testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
296 geterr, req := e2SubsReq.Get()
298 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
302 case <-time.After(15 * time.Second):
303 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
308 func (e2termConn *testingE2termControl) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
309 xapp.Logger.Info("(%s) handle_e2term_subs_resp", e2termConn.desc)
310 e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
312 //---------------------------------
313 // e2term activity: Send Subs Resp
314 //---------------------------------
315 xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
317 resp := &e2ap.E2APSubscriptionResponse{}
319 resp.RequestId.Id = req.RequestId.Id
320 resp.RequestId.Seq = req.RequestId.Seq
321 resp.FunctionId = req.FunctionId
323 resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
324 for index := int(0); index < len(req.ActionSetups); index++ {
325 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
328 for index := uint64(0); index < 1; index++ {
329 item := e2ap.ActionNotAdmittedItem{}
330 item.ActionId = index
331 item.Cause.Content = 1
332 item.Cause.CauseVal = 1
333 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
337 xapp.Logger.Debug("%s", e2SubsResp.String())
338 packerr, packedMsg := e2SubsResp.Pack(nil)
340 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
343 params := &RMRParams{&xapp.RMRParams{}}
344 params.Mtype = xapp.RIC_SUB_RESP
345 params.SubId = msg.SubId
346 params.Payload = packedMsg.Buf
347 params.Meid = msg.Meid
351 snderr := e2termConn.RmrSend(params)
353 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
357 //-----------------------------------------------------------------------------
359 //-----------------------------------------------------------------------------
360 func (e2termConn *testingE2termControl) handle_e2term_subs_fail(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
361 xapp.Logger.Info("(%s) handle_e2term_subs_fail", e2termConn.desc)
362 e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
364 //---------------------------------
365 // e2term activity: Send Subs Fail
366 //---------------------------------
367 xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.desc)
369 resp := &e2ap.E2APSubscriptionFailure{}
370 resp.RequestId.Id = req.RequestId.Id
371 resp.RequestId.Seq = req.RequestId.Seq
372 resp.FunctionId = req.FunctionId
374 resp.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(resp.ActionNotAdmittedList.Items))
375 for index := int(0); index < len(resp.ActionNotAdmittedList.Items); index++ {
376 resp.ActionNotAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
377 resp.ActionNotAdmittedList.Items[index].Cause.Content = 3 // CauseMisc
378 resp.ActionNotAdmittedList.Items[index].Cause.CauseVal = 4 // unspecified
382 xapp.Logger.Debug("%s", e2SubsFail.String())
383 packerr, packedMsg := e2SubsFail.Pack(nil)
385 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
388 params := &RMRParams{&xapp.RMRParams{}}
389 params.Mtype = xapp.RIC_SUB_FAILURE
390 params.SubId = msg.SubId
391 params.Payload = packedMsg.Buf
392 params.Meid = msg.Meid
396 snderr := e2termConn.RmrSend(params)
398 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
402 //-----------------------------------------------------------------------------
404 //-----------------------------------------------------------------------------
405 func (e2termConn *testingE2termControl) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *RMRParams) {
406 xapp.Logger.Info("(%s) handle_e2term_subs_del_req", e2termConn.desc)
407 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
409 //---------------------------------
410 // e2term activity: Recv Subs Del Req
411 //---------------------------------
413 case msg := <-e2termConn.rmrConChan:
414 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
415 testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
417 xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
419 packedData := &packer.PackedData{}
420 packedData.Buf = msg.Payload
421 unpackerr := e2SubsDelReq.UnPack(packedData)
422 if unpackerr != nil {
423 testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
425 geterr, req := e2SubsDelReq.Get()
427 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
431 case <-time.After(15 * time.Second):
432 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
437 func handle_e2term_recv_empty() bool {
438 if len(e2termConn.rmrConChan) > 0 {
444 func (e2termConn *testingE2termControl) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
445 xapp.Logger.Info("(%s) handle_e2term_subs_del_resp", e2termConn.desc)
446 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
448 //---------------------------------
449 // e2term activity: Send Subs Del Resp
450 //---------------------------------
451 xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
453 resp := &e2ap.E2APSubscriptionDeleteResponse{}
454 resp.RequestId.Id = req.RequestId.Id
455 resp.RequestId.Seq = req.RequestId.Seq
456 resp.FunctionId = req.FunctionId
458 e2SubsDelResp.Set(resp)
459 xapp.Logger.Debug("%s", e2SubsDelResp.String())
460 packerr, packedMsg := e2SubsDelResp.Pack(nil)
462 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
465 params := &RMRParams{&xapp.RMRParams{}}
466 params.Mtype = xapp.RIC_SUB_DEL_RESP
467 params.SubId = msg.SubId
468 params.Payload = packedMsg.Buf
469 params.Meid = msg.Meid
473 snderr := e2termConn.RmrSend(params)
475 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
479 //-----------------------------------------------------------------------------
481 //-----------------------------------------------------------------------------
482 func (e2termConn *testingE2termControl) handle_e2term_subs_del_fail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
483 xapp.Logger.Info("(%s) handle_e2term_del_subs_fail", e2termConn.desc)
484 e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
486 //---------------------------------
487 // e2term activity: Send Subs Del Fail
488 //---------------------------------
489 xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.desc)
491 resp := &e2ap.E2APSubscriptionDeleteFailure{}
492 resp.RequestId.Id = req.RequestId.Id
493 resp.RequestId.Seq = req.RequestId.Seq
494 resp.FunctionId = req.FunctionId
495 resp.Cause.Content = 3 // CauseMisc
496 resp.Cause.CauseVal = 4 // unspecified
498 e2SubsDelFail.Set(resp)
499 xapp.Logger.Debug("%s", e2SubsDelFail.String())
500 packerr, packedMsg := e2SubsDelFail.Pack(nil)
502 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
505 params := &RMRParams{&xapp.RMRParams{}}
506 params.Mtype = xapp.RIC_SUB_DEL_FAILURE
507 params.SubId = msg.SubId
508 params.Payload = packedMsg.Buf
509 params.Meid = msg.Meid
513 snderr := e2termConn.RmrSend(params)
515 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
519 //-----------------------------------------------------------------------------
521 //-----------------------------------------------------------------------------
522 func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool {
524 for ; i <= secs*2; i++ {
525 if mc.c.registry.GetSubscription(uint16(e2SubsId)) == nil {
528 time.Sleep(500 * time.Millisecond)
530 testError(t, "(general) no clean within %d secs", secs)
534 func (mc *testingMainControl) wait_subs_trans_clean(t *testing.T, e2SubsId int, secs int) bool {
536 for ; i <= secs*2; i++ {
537 subs := mc.c.registry.GetSubscription(uint16(e2SubsId))
541 trans := subs.GetTransaction()
545 time.Sleep(500 * time.Millisecond)
547 testError(t, "(general) no clean within %d secs", secs)
551 func (mc *testingMainControl) get_seqcnt(t *testing.T) uint16 {
552 mc.c.registry.mutex.Lock()
553 defer mc.c.registry.mutex.Unlock()
554 return mc.c.registry.counter
557 func (mc *testingMainControl) wait_seqcnt_change(t *testing.T, orig uint16, secs int) (uint16, bool) {
559 for ; i <= secs*2; i++ {
560 mc.c.registry.mutex.Lock()
561 curr := mc.c.registry.counter
562 mc.c.registry.mutex.Unlock()
566 time.Sleep(500 * time.Millisecond)
568 testError(t, "(general) no seq change within %d secs", secs)
572 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
573 return mc.c.msgCounter
576 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
578 for ; i <= secs*2; i++ {
579 curr := mc.c.msgCounter
583 time.Sleep(500 * time.Millisecond)
585 testError(t, "(general) no msg counter change within %d secs", secs)
589 //-----------------------------------------------------------------------------
590 // TestSubReqAndSubDelOk
593 // +-------+ +---------+ +---------+
594 // | xapp | | submgr | | e2term |
595 // +-------+ +---------+ +---------+
598 // |------------->| |
601 // | |------------->|
604 // | |<-------------|
607 // |<-------------| |
611 // |------------->| |
614 // | |------------->|
617 // | |<-------------|
620 // |<-------------| |
622 //-----------------------------------------------------------------------------
623 func TestSubReqAndSubDelOk(t *testing.T) {
624 xapp.Logger.Info("TestSubReqAndSubDelOk")
626 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
627 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
628 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
629 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
631 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
632 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
633 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
634 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
636 //Wait that subs is cleaned
637 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
640 //-----------------------------------------------------------------------------
641 // TestSubReqRetransmission
644 // +-------+ +---------+ +---------+
645 // | xapp | | submgr | | e2term |
646 // +-------+ +---------+ +---------+
649 // |------------->| |
652 // | |------------->|
656 // |------------->| |
659 // | |<-------------|
662 // |<-------------| |
667 //-----------------------------------------------------------------------------
668 func TestSubReqRetransmission(t *testing.T) {
669 xapp.Logger.Info("TestSubReqRetransmission")
672 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
673 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
675 seqBef := mainCtrl.get_msgcounter(t)
676 xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
677 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
679 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
680 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
683 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
684 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
685 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
686 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
688 //Wait that subs is cleaned
689 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
692 //-----------------------------------------------------------------------------
693 // TestSubDelReqRetransmission
696 // +-------+ +---------+ +---------+
697 // | xapp | | submgr | | e2term |
698 // +-------+ +---------+ +---------+
704 // |------------->| |
707 // | |------------->|
712 // |------------->| |
715 // | |<-------------|
718 // |<-------------| |
720 //-----------------------------------------------------------------------------
721 func TestSubDelReqRetransmission(t *testing.T) {
722 xapp.Logger.Info("TestSubDelReqRetransmission")
725 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
726 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
727 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
728 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
731 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
732 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
734 seqBef := mainCtrl.get_msgcounter(t)
735 xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
736 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
738 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
739 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
741 //Wait that subs is cleaned
742 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
745 //-----------------------------------------------------------------------------
746 // TestSubDelReqCollision
749 // +-------+ +---------+ +---------+
750 // | xapp | | submgr | | e2term |
751 // +-------+ +---------+ +---------+
757 // |------------->| |
760 // | |------------->|
765 // |------------->| |
768 // | |<-------------|
771 // |<-------------| |
773 //-----------------------------------------------------------------------------
774 func TestSubDelReqCollision(t *testing.T) {
775 xapp.Logger.Info("TestSubDelReqCollision")
778 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
779 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
780 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
781 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
784 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
785 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
787 seqBef := mainCtrl.get_msgcounter(t)
788 deltranscol := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
789 xappConn1.handle_xapp_subs_del_req(t, deltranscol, e2SubsId) //Colliding SubDelReq
790 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
792 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
793 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
795 //Wait that subs is cleaned
796 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
799 //-----------------------------------------------------------------------------
800 // TestSubReqAndSubDelOkTwoParallel
803 // +-------+ +---------+ +---------+
804 // | xapp | | submgr | | e2term |
805 // +-------+ +---------+ +---------+
810 // |------------->| |
813 // | |------------->|
816 // |------------->| |
819 // | |------------->|
822 // | |<-------------|
824 // | |<-------------|
827 // |<-------------| |
829 // |<-------------| |
831 // | [SUBS 1 DELETE] |
833 // | [SUBS 2 DELETE] |
836 //-----------------------------------------------------------------------------
837 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
838 xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
841 cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
842 crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
845 cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
846 crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
849 e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
850 e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
853 e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
854 e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
857 deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
858 delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
859 e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
860 xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
861 //Wait that subs is cleaned
862 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
865 deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
866 delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
867 e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
868 xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
869 //Wait that subs is cleaned
870 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
873 //-----------------------------------------------------------------------------
874 // TestSameSubsDiffRan
875 // Same subscription to different RANs
878 // +-------+ +---------+ +---------+
879 // | xapp | | submgr | | e2term |
880 // +-------+ +---------+ +---------+
885 // |------------->| |
888 // | |------------->|
891 // | |<-------------|
894 // |<-------------| |
897 // |------------->| |
900 // | |------------->|
903 // | |<-------------|
906 // |<-------------| |
908 // | [SUBS r1 DELETE] |
910 // | [SUBS r2 DELETE] |
913 //-----------------------------------------------------------------------------
914 func TestSameSubsDiffRan(t *testing.T) {
915 xapp.Logger.Info("TestSameSubsDiffRan")
918 cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
919 xappConn1.handle_xapp_subs_req(t, cretrans1)
920 crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
921 e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
922 e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
925 cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
926 xappConn1.handle_xapp_subs_req(t, cretrans2)
927 crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
928 e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
929 e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
932 deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
933 xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
934 delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
935 e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
936 xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
937 //Wait that subs is cleaned
938 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
941 deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
942 xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
943 delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
944 e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
945 xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
946 //Wait that subs is cleaned
947 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
950 //-----------------------------------------------------------------------------
951 // TestSubReqRetryInSubmgr
954 // +-------+ +---------+ +---------+
955 // | xapp | | submgr | | e2term |
956 // +-------+ +---------+ +---------+
959 // |------------->| |
962 // | |------------->|
966 // | |------------->|
969 // | |<-------------|
972 // |<-------------| |
977 //-----------------------------------------------------------------------------
979 func TestSubReqRetryInSubmgr(t *testing.T) {
981 xapp.Logger.Info("TestSubReqRetryInSubmgr start")
983 // Xapp: Send SubsReq
984 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
986 // E2t: Receive 1st SubsReq
987 e2termConn.handle_e2term_subs_req(t)
989 // E2t: Receive 2nd SubsReq and send SubsResp
990 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
991 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
993 // Xapp: Receive SubsResp
994 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
996 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
997 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
998 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
999 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1001 // Wait that subs is cleaned
1002 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1005 //-----------------------------------------------------------------------------
1006 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1009 // +-------+ +---------+ +---------+
1010 // | xapp | | submgr | | e2term |
1011 // +-------+ +---------+ +---------+
1014 // |------------->| |
1017 // | |------------->|
1021 // | |------------->|
1024 // | |------------->|
1028 // | |------------->|
1032 // | |<-------------|
1035 //-----------------------------------------------------------------------------
1037 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1039 xapp.Logger.Info("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1041 // Xapp: Send SubsReq
1042 xappConn1.handle_xapp_subs_req(t, nil)
1044 // E2t: Receive 1st SubsReq
1045 e2termConn.handle_e2term_subs_req(t)
1047 // E2t: Receive 2nd SubsReq
1048 e2termConn.handle_e2term_subs_req(t)
1050 // E2t: Send receive SubsDelReq and send SubsResp
1051 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1052 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1054 // Wait that subs is cleaned
1055 mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1058 //-----------------------------------------------------------------------------
1059 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1062 // +-------+ +---------+ +---------+
1063 // | xapp | | submgr | | e2term |
1064 // +-------+ +---------+ +---------+
1067 // |------------->| |
1070 // | |------------->|
1074 // | |------------->|
1077 // | |------------->|
1081 // | |------------->|
1085 //-----------------------------------------------------------------------------
1087 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1089 xapp.Logger.Info("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1091 // Xapp: Send SubsReq
1092 xappConn1.handle_xapp_subs_req(t, nil)
1094 // E2t: Receive 1st SubsReq
1095 e2termConn.handle_e2term_subs_req(t)
1097 // E2t: Receive 2nd SubsReq
1098 e2termConn.handle_e2term_subs_req(t)
1100 // E2t: Receive 1st SubsDelReq
1101 e2termConn.handle_e2term_subs_del_req(t)
1103 // E2t: Receive 2nd SubsDelReq
1104 delreq, _ := e2termConn.handle_e2term_subs_del_req(t)
1106 // Wait that subs is cleaned
1107 mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1110 //-----------------------------------------------------------------------------
1111 // TestSubReqSubFailRespInSubmgr
1114 // +-------+ +---------+ +---------+
1115 // | xapp | | submgr | | e2term |
1116 // +-------+ +---------+ +---------+
1119 // |------------->| |
1122 // | |------------->|
1125 // | |<-------------|
1128 // |<-------------| |
1131 //-----------------------------------------------------------------------------
1133 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1135 xapp.Logger.Info("TestSubReqSubFailRespInSubmgr start")
1137 // Xapp: Send SubsReq
1138 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1140 // E2t: Receive SubsReq and send SubsFail
1141 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1142 e2termConn.handle_e2term_subs_fail(t, crereq, cremsg)
1144 // Xapp: Receive SubsFail
1145 e2SubsId := xappConn1.handle_xapp_subs_fail(t, cretrans)
1147 // Wait that subs is cleaned
1148 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1151 //-----------------------------------------------------------------------------
1152 // TestSubDelReqRetryInSubmgr
1155 // +-------+ +---------+ +---------+
1156 // | xapp | | submgr | | e2term |
1157 // +-------+ +---------+ +---------+
1159 // | [SUBS CREATE] |
1163 // |------------->| |
1166 // | |------------->|
1169 // | |------------->|
1172 // | |<-------------|
1175 // |<-------------| |
1177 //-----------------------------------------------------------------------------
1179 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1181 xapp.Logger.Info("TestSubDelReqRetryInSubmgr start")
1184 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1185 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1186 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1187 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1190 // Xapp: Send SubsDelReq
1191 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1193 // E2t: Receive 1st SubsDelReq
1194 e2termConn.handle_e2term_subs_del_req(t)
1196 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1197 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1198 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1200 // Xapp: Receive SubsDelResp
1201 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1203 // Wait that subs is cleaned
1204 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1207 //-----------------------------------------------------------------------------
1208 // TestSubDelReqTwoRetriesNoRespInSubmgr
1211 // +-------+ +---------+ +---------+
1212 // | xapp | | submgr | | e2term |
1213 // +-------+ +---------+ +---------+
1215 // | [SUBS CREATE] |
1219 // |------------->| |
1222 // | |------------->|
1225 // | |------------->|
1229 // |<-------------| |
1231 //-----------------------------------------------------------------------------
1233 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1235 xapp.Logger.Info("TestSubDelReTwoRetriesNoRespInSubmgr start")
1238 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1239 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1240 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1241 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1244 // Xapp: Send SubsDelReq
1245 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1247 // E2t: Receive 1st SubsDelReq
1248 e2termConn.handle_e2term_subs_del_req(t)
1250 // E2t: Receive 2nd SubsDelReq
1251 e2termConn.handle_e2term_subs_del_req(t)
1253 // Xapp: Receive SubsDelResp
1254 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1256 // Wait that subs is cleaned
1257 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1260 //-----------------------------------------------------------------------------
1261 // TestSubDelReqSubDelFailRespInSubmgr
1264 // +-------+ +---------+ +---------+
1265 // | xapp | | submgr | | e2term |
1266 // +-------+ +---------+ +---------+
1268 // | [SUBS CREATE] |
1272 // |------------->| |
1275 // | |------------->|
1278 // | |<-------------|
1281 // |<-------------| |
1284 //-----------------------------------------------------------------------------
1286 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1288 xapp.Logger.Info("TestSubReqSubDelFailRespInSubmgr start")
1291 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1292 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1293 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1294 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1296 // Xapp: Send SubsDelReq
1297 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1299 // E2t: Send receive SubsDelReq and send SubsDelFail
1300 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1301 e2termConn.handle_e2term_subs_del_fail(t, delreq, delmsg)
1303 // Xapp: Receive SubsDelResp
1304 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1306 // Wait that subs is cleaned
1307 mainCtrl.wait_subs_clean(t, e2SubsId, 10)