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("handle_xapp_subs_req")
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 := &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("handle_xapp_subs_resp")
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_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId int) *xappTransaction {
152 xapp.Logger.Info("handle_xapp_subs_del_req")
153 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
155 //---------------------------------
156 // xapp activity: Send Subs Del Req
157 //---------------------------------
158 xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
160 req := &e2ap.E2APSubscriptionDeleteRequest{}
162 req.RequestId.Seq = uint32(e2SubsId)
165 e2SubsDelReq.Set(req)
166 xapp.Logger.Debug("%s", e2SubsDelReq.String())
167 err, packedMsg := e2SubsDelReq.Pack(nil)
169 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
173 var trans *xappTransaction = oldTrans
175 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
178 params := &xapp.RMRParams{}
179 params.Mtype = xapp.RIC_SUB_DEL_REQ
180 params.SubId = e2SubsId
181 params.Payload = packedMsg.Buf
182 params.Meid = trans.meid
183 params.Xid = trans.xid
186 snderr := xappConn.RmrSend(params)
188 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
194 //-----------------------------------------------------------------------------
196 //-----------------------------------------------------------------------------
197 func (xappConn *testingXappControl) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) {
198 xapp.Logger.Info("handle_xapp_subs_del_resp")
199 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
201 //---------------------------------
202 // xapp activity: Recv Subs Del Resp
203 //---------------------------------
205 case msg := <-xappConn.rmrConChan:
206 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
207 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])
209 } else if msg.Xid != trans.xid {
210 testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
213 packedData := &packer.PackedData{}
214 packedData.Buf = msg.Payload
215 unpackerr := e2SubsDelResp.UnPack(packedData)
216 if unpackerr != nil {
217 testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
219 geterr, resp := e2SubsDelResp.Get()
221 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
223 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)
226 case <-time.After(15 * time.Second):
227 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
231 //-----------------------------------------------------------------------------
233 //-----------------------------------------------------------------------------
234 func (e2termConn *testingE2termControl) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) {
235 xapp.Logger.Info("handle_e2term_subs_req")
236 e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
238 //---------------------------------
239 // e2term activity: Recv Subs Req
240 //---------------------------------
242 case msg := <-e2termConn.rmrConChan:
243 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
244 testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
246 xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc)
247 packedData := &packer.PackedData{}
248 packedData.Buf = msg.Payload
249 unpackerr := e2SubsReq.UnPack(packedData)
250 if unpackerr != nil {
251 testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
253 geterr, req := e2SubsReq.Get()
255 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
259 case <-time.After(15 * time.Second):
260 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
265 func (e2termConn *testingE2termControl) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) {
266 xapp.Logger.Info("handle_e2term_subs_resp")
267 e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
269 //---------------------------------
270 // e2term activity: Send Subs Resp
271 //---------------------------------
272 xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
274 resp := &e2ap.E2APSubscriptionResponse{}
276 resp.RequestId.Id = req.RequestId.Id
277 resp.RequestId.Seq = req.RequestId.Seq
278 resp.FunctionId = req.FunctionId
280 resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
281 for index := int(0); index < len(req.ActionSetups); index++ {
282 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
285 for index := uint64(0); index < 1; index++ {
286 item := e2ap.ActionNotAdmittedItem{}
287 item.ActionId = index
288 item.Cause.Content = 1
289 item.Cause.CauseVal = 1
290 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
294 xapp.Logger.Debug("%s", e2SubsResp.String())
295 packerr, packedMsg := e2SubsResp.Pack(nil)
297 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
300 params := &xapp.RMRParams{}
301 params.Mtype = xapp.RIC_SUB_RESP
302 params.SubId = msg.SubId
303 params.Payload = packedMsg.Buf
304 params.Meid = msg.Meid
308 snderr := e2termConn.RmrSend(params)
310 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
314 //-----------------------------------------------------------------------------
316 //-----------------------------------------------------------------------------
317 func (e2termConn *testingE2termControl) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) {
318 xapp.Logger.Info("handle_e2term_subs_del_req")
319 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
321 //---------------------------------
322 // e2term activity: Recv Subs Del Req
323 //---------------------------------
325 case msg := <-e2termConn.rmrConChan:
326 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
327 testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
329 xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
331 packedData := &packer.PackedData{}
332 packedData.Buf = msg.Payload
333 unpackerr := e2SubsDelReq.UnPack(packedData)
334 if unpackerr != nil {
335 testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
337 geterr, req := e2SubsDelReq.Get()
339 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
343 case <-time.After(15 * time.Second):
344 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
349 func handle_e2term_recv_empty() bool {
350 if len(e2termConn.rmrConChan) > 0 {
356 func (e2termConn *testingE2termControl) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
357 xapp.Logger.Info("handle_e2term_subs_del_resp")
358 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
360 //---------------------------------
361 // e2term activity: Send Subs Del Resp
362 //---------------------------------
363 xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
365 resp := &e2ap.E2APSubscriptionDeleteResponse{}
366 resp.RequestId.Id = req.RequestId.Id
367 resp.RequestId.Seq = req.RequestId.Seq
368 resp.FunctionId = req.FunctionId
370 e2SubsDelResp.Set(resp)
371 xapp.Logger.Debug("%s", e2SubsDelResp.String())
372 packerr, packedMsg := e2SubsDelResp.Pack(nil)
374 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
377 params := &xapp.RMRParams{}
378 params.Mtype = xapp.RIC_SUB_DEL_RESP
379 params.SubId = msg.SubId
380 params.Payload = packedMsg.Buf
381 params.Meid = msg.Meid
385 snderr := e2termConn.RmrSend(params)
387 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
392 //-----------------------------------------------------------------------------
394 //-----------------------------------------------------------------------------
395 func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool {
397 for ; i <= secs*2; i++ {
398 if mc.c.registry.IsValidSequenceNumber(uint16(e2SubsId)) == false {
401 time.Sleep(500 * time.Millisecond)
403 testError(t, "(general) no clean within %d secs", secs)
407 func (mc *testingMainControl) get_seqcnt(t *testing.T) uint16 {
408 mc.c.registry.mutex.Lock()
409 defer mc.c.registry.mutex.Unlock()
410 return mc.c.registry.counter
413 func (mc *testingMainControl) wait_seqcnt_change(t *testing.T, orig uint16, secs int) (uint16, bool) {
415 for ; i <= secs*2; i++ {
416 mc.c.registry.mutex.Lock()
417 curr := mc.c.registry.counter
418 mc.c.registry.mutex.Unlock()
422 time.Sleep(500 * time.Millisecond)
424 testError(t, "(general) no seq change within %d secs", secs)
428 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
429 return mc.c.msgCounter
432 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
434 for ; i <= secs*2; i++ {
435 curr := mc.c.msgCounter
439 time.Sleep(500 * time.Millisecond)
441 testError(t, "(general) no msg counter change within %d secs", secs)
445 //-----------------------------------------------------------------------------
446 // TestSubReqAndSubDelOk
449 // +-------+ +---------+ +---------+
450 // | xapp | | submgr | | e2term |
451 // +-------+ +---------+ +---------+
454 // |------------->| |
457 // | |------------->|
460 // | |<-------------|
463 // |<-------------| |
467 // |------------->| |
470 // | |------------->|
473 // | |<-------------|
476 // |<-------------| |
478 //-----------------------------------------------------------------------------
479 func TestSubReqAndSubDelOk(t *testing.T) {
480 xapp.Logger.Info("TestSubReqAndSubDelOk")
482 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
483 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
484 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
485 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
487 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
488 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
489 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
490 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
492 //Wait that subs is cleaned
493 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
496 //-----------------------------------------------------------------------------
497 // TestSubReqRetransmission
500 // +-------+ +---------+ +---------+
501 // | xapp | | submgr | | e2term |
502 // +-------+ +---------+ +---------+
505 // |------------->| |
508 // | |------------->|
512 // |------------->| |
515 // | |<-------------|
518 // |<-------------| |
523 //-----------------------------------------------------------------------------
524 func TestSubReqRetransmission(t *testing.T) {
525 xapp.Logger.Info("TestSubReqRetransmission")
528 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
529 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
531 seqBef := mainCtrl.get_msgcounter(t)
532 xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
533 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
535 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
536 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
539 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
540 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
541 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
542 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
544 //Wait that subs is cleaned
545 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
548 //-----------------------------------------------------------------------------
549 // TestSubDelReqRetransmission
552 // +-------+ +---------+ +---------+
553 // | xapp | | submgr | | e2term |
554 // +-------+ +---------+ +---------+
560 // |------------->| |
563 // | |------------->|
566 // |------------->| |
569 // | |<-------------|
572 // |<-------------| |
574 //-----------------------------------------------------------------------------
575 func TestSubDelReqRetransmission(t *testing.T) {
576 xapp.Logger.Info("TestSubDelReqRetransmission")
579 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
580 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
581 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
582 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
585 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
586 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
588 seqBef := mainCtrl.get_msgcounter(t)
589 xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
590 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
592 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
593 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
595 //Wait that subs is cleaned
596 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
599 //-----------------------------------------------------------------------------
600 // TestSubReqAndSubDelOkTwoParallel
603 // +-------+ +---------+ +---------+
604 // | xapp | | submgr | | e2term |
605 // +-------+ +---------+ +---------+
610 // |------------->| |
613 // | |------------->|
616 // |------------->| |
619 // | |------------->|
622 // | |<-------------|
624 // | |<-------------|
627 // |<-------------| |
629 // |<-------------| |
631 // | [SUBS 1 DELETE] |
633 // | [SUBS 2 DELETE] |
636 //-----------------------------------------------------------------------------
637 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
638 xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
641 cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
642 crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
645 cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
646 crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
649 e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
650 e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
653 e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
654 e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
657 deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
658 delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
659 e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
660 xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
661 //Wait that subs is cleaned
662 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
665 deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
666 delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
667 e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
668 xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
669 //Wait that subs is cleaned
670 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
673 //-----------------------------------------------------------------------------
674 // TestSameSubsDiffRan
675 // Same subscription to different RANs
678 // +-------+ +---------+ +---------+
679 // | xapp | | submgr | | e2term |
680 // +-------+ +---------+ +---------+
685 // |------------->| |
688 // | |------------->|
691 // | |<-------------|
694 // |<-------------| |
697 // |------------->| |
700 // | |------------->|
703 // | |<-------------|
706 // |<-------------| |
708 // | [SUBS r1 DELETE] |
710 // | [SUBS r2 DELETE] |
713 //-----------------------------------------------------------------------------
714 func TestSameSubsDiffRan(t *testing.T) {
715 xapp.Logger.Info("TestSameSubsDiffRan")
718 cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
719 xappConn1.handle_xapp_subs_req(t, cretrans1)
720 crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
721 e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
722 e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
725 cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
726 xappConn1.handle_xapp_subs_req(t, cretrans2)
727 crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
728 e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
729 e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
732 deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
733 xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
734 delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
735 e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
736 xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
737 //Wait that subs is cleaned
738 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
741 deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
742 xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
743 delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
744 e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
745 xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
746 //Wait that subs is cleaned
747 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)