pkg/control/messaging_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   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
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  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 ==================================================================================
  18 */
  19
  20 package control
  21
  22 import (
  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"
  27         "testing"
  28         "time"
  29 )
  30
  31 //-----------------------------------------------------------------------------
  32 //
  33 //-----------------------------------------------------------------------------
  34 var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  35
  36 //-----------------------------------------------------------------------------
  37 //
  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()
  42
  43         //---------------------------------
  44         // xapp activity: Send Subs Req
  45         //---------------------------------
  46         xapp.Logger.Info("(%s) Send Subs Req", xappConn.desc)
  47
  48         req := &e2ap.E2APSubscriptionRequest{}
  49
  50         req.RequestId.Id = 1
  51         req.RequestId.Seq = 0
  52         req.FunctionId = 1
  53
  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
  58
  59         // gnb -> enb outgoing
  60         // enb -> gnb incoming
  61         // X2 36423-f40.doc
  62         req.EventTriggerDefinition.InterfaceDirection = e2ap.E2AP_InterfaceDirectionIncoming
  63         req.EventTriggerDefinition.ProcedureCode = 5 //28 35
  64         req.EventTriggerDefinition.TypeOfMessage = e2ap.E2AP_InitiatingMessage
  65
  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
  75
  76         e2SubsReq.Set(req)
  77         xapp.Logger.Debug("%s", e2SubsReq.String())
  78         err, packedMsg := e2SubsReq.Pack(nil)
  79         if err != nil {
  80                 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
  81                 return nil
  82         }
  83
  84         var trans *xappTransaction = oldTrans
  85         if trans == nil {
  86                 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
  87         }
  88
  89         params := &RMRParams{&xapp.RMRParams{}}
  90         params.Mtype = xapp.RIC_SUB_REQ
  91         params.SubId = -1
  92         params.Payload = packedMsg.Buf
  93         params.Meid = trans.meid
  94         params.Xid = trans.xid
  95         params.Mbuf = nil
  96
  97         snderr := xappConn.RmrSend(params)
  98         if snderr != nil {
  99                 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
 100                 return nil
 101         }
 102         return trans
 103 }
 104
 105 //-----------------------------------------------------------------------------
 106 //
 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()
 111         var e2SubsId int
 112
 113         //---------------------------------
 114         // xapp activity: Recv Subs Resp
 115         //---------------------------------
 116         select {
 117         case msg := <-xappConn.rmrConChan:
 118                 xappConn.DecMsgCnt()
 119                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] {
 120                         testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype])
 121                         return -1
 122                 } else if msg.Xid != trans.xid {
 123                         testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
 124                         return -1
 125                 } else {
 126                         packedData := &packer.PackedData{}
 127                         packedData.Buf = msg.Payload
 128                         e2SubsId = msg.SubId
 129                         unpackerr := e2SubsResp.UnPack(packedData)
 130
 131                         if unpackerr != nil {
 132                                 testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
 133                         }
 134                         geterr, resp := e2SubsResp.Get()
 135                         if geterr != nil {
 136                                 testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error())
 137                         }
 138
 139                         xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
 140                         return e2SubsId
 141                 }
 142         case <-time.After(15 * time.Second):
 143                 testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc)
 144                 return -1
 145         }
 146         return -1
 147 }
 148
 149 //-----------------------------------------------------------------------------
 150 //
 151 //-----------------------------------------------------------------------------
 152 func (xappConn *testingXappControl) handle_xapp_subs_fail(t *testing.T, trans *xappTransaction) int {
 153         xapp.Logger.Info("(%s) handle_xapp_subs_fail", xappConn.desc)
 154         e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
 155         var e2SubsId int
 156
 157         //-------------------------------
 158         // xapp activity: Recv Subs Fail
 159         //-------------------------------
 160         select {
 161         case msg := <-xappConn.rmrConChan:
 162                 xappConn.DecMsgCnt()
 163                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] {
 164                         testError(t, "(%s) Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype])
 165                         return -1
 166                 } else if msg.Xid != trans.xid {
 167                         testError(t, "(%s) Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
 168                         return -1
 169                 } else {
 170                         packedData := &packer.PackedData{}
 171                         packedData.Buf = msg.Payload
 172                         e2SubsId = msg.SubId
 173                         unpackerr := e2SubsFail.UnPack(packedData)
 174
 175                         if unpackerr != nil {
 176                                 testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.desc, unpackerr.Error())
 177                         }
 178                         geterr, resp := e2SubsFail.Get()
 179                         if geterr != nil {
 180                                 testError(t, "(%s) RIC_SUB_FAILURE get failed err: %s", xappConn.desc, geterr.Error())
 181                         }
 182
 183                         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                         return e2SubsId
 185                 }
 186         case <-time.After(15 * time.Second):
 187                 testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.desc)
 188                 return -1
 189         }
 190         return -1
 191 }
 192
 193 //-----------------------------------------------------------------------------
 194 //
 195 //-----------------------------------------------------------------------------
 196 func (xappConn *testingXappControl) handle_xapp_subs_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId int) *xappTransaction {
 197         xapp.Logger.Info("(%s) handle_xapp_subs_del_req", xappConn.desc)
 198         e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
 199
 200         //---------------------------------
 201         // xapp activity: Send Subs Del Req
 202         //---------------------------------
 203         xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
 204
 205         req := &e2ap.E2APSubscriptionDeleteRequest{}
 206         req.RequestId.Id = 1
 207         req.RequestId.Seq = uint32(e2SubsId)
 208         req.FunctionId = 1
 209
 210         e2SubsDelReq.Set(req)
 211         xapp.Logger.Debug("%s", e2SubsDelReq.String())
 212         err, packedMsg := e2SubsDelReq.Pack(nil)
 213         if err != nil {
 214                 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
 215                 return nil
 216         }
 217
 218         var trans *xappTransaction = oldTrans
 219         if trans == nil {
 220                 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
 221         }
 222
 223         params := &RMRParams{&xapp.RMRParams{}}
 224         params.Mtype = xapp.RIC_SUB_DEL_REQ
 225         params.SubId = e2SubsId
 226         params.Payload = packedMsg.Buf
 227         params.Meid = trans.meid
 228         params.Xid = trans.xid
 229         params.Mbuf = nil
 230
 231         snderr := xappConn.RmrSend(params)
 232         if snderr != nil {
 233                 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
 234                 return nil
 235         }
 236         return trans
 237 }
 238
 239 //-----------------------------------------------------------------------------
 240 //
 241 //-----------------------------------------------------------------------------
 242 func (xappConn *testingXappControl) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) {
 243         xapp.Logger.Info("(%s) handle_xapp_subs_del_resp", xappConn.desc)
 244         e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
 245
 246         //---------------------------------
 247         // xapp activity: Recv Subs Del Resp
 248         //---------------------------------
 249         select {
 250         case msg := <-xappConn.rmrConChan:
 251                 xappConn.DecMsgCnt()
 252                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
 253                         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])
 254                         return
 255                 } else if msg.Xid != trans.xid {
 256                         testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
 257                         return
 258                 } else {
 259                         packedData := &packer.PackedData{}
 260                         packedData.Buf = msg.Payload
 261                         unpackerr := e2SubsDelResp.UnPack(packedData)
 262                         if unpackerr != nil {
 263                                 testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
 264                         }
 265                         geterr, resp := e2SubsDelResp.Get()
 266                         if geterr != nil {
 267                                 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
 268                         }
 269                         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)
 270                         return
 271                 }
 272         case <-time.After(15 * time.Second):
 273                 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
 274         }
 275 }
 276
 277 //-----------------------------------------------------------------------------
 278 //
 279 //-----------------------------------------------------------------------------
 280 func (e2termConn *testingE2termControl) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *RMRParams) {
 281         xapp.Logger.Info("(%s) handle_e2term_subs_req", e2termConn.desc)
 282         e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
 283
 284         //---------------------------------
 285         // e2term activity: Recv Subs Req
 286         //---------------------------------
 287         select {
 288         case msg := <-e2termConn.rmrConChan:
 289                 e2termConn.DecMsgCnt()
 290                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
 291                         testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 292                 } else {
 293                         xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc)
 294                         packedData := &packer.PackedData{}
 295                         packedData.Buf = msg.Payload
 296                         unpackerr := e2SubsReq.UnPack(packedData)
 297                         if unpackerr != nil {
 298                                 testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
 299                         }
 300                         geterr, req := e2SubsReq.Get()
 301                         if geterr != nil {
 302                                 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 303                         }
 304                         return req, msg
 305                 }
 306         case <-time.After(15 * time.Second):
 307                 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
 308         }
 309         return nil, nil
 310 }
 311
 312 func (e2termConn *testingE2termControl) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
 313         xapp.Logger.Info("(%s) handle_e2term_subs_resp", e2termConn.desc)
 314         e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
 315
 316         //---------------------------------
 317         // e2term activity: Send Subs Resp
 318         //---------------------------------
 319         xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
 320
 321         resp := &e2ap.E2APSubscriptionResponse{}
 322
 323         resp.RequestId.Id = req.RequestId.Id
 324         resp.RequestId.Seq = req.RequestId.Seq
 325         resp.FunctionId = req.FunctionId
 326
 327         resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
 328         for index := int(0); index < len(req.ActionSetups); index++ {
 329                 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
 330         }
 331
 332         for index := uint64(0); index < 1; index++ {
 333                 item := e2ap.ActionNotAdmittedItem{}
 334                 item.ActionId = index
 335                 item.Cause.Content = 1
 336                 item.Cause.CauseVal = 1
 337                 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
 338         }
 339
 340         e2SubsResp.Set(resp)
 341         xapp.Logger.Debug("%s", e2SubsResp.String())
 342         packerr, packedMsg := e2SubsResp.Pack(nil)
 343         if packerr != nil {
 344                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 345         }
 346
 347         params := &RMRParams{&xapp.RMRParams{}}
 348         params.Mtype = xapp.RIC_SUB_RESP
 349         //params.SubId = msg.SubId
 350         params.SubId = -1
 351         params.Payload = packedMsg.Buf
 352         params.Meid = msg.Meid
 353         //params.Xid = msg.Xid
 354         params.Mbuf = nil
 355
 356         snderr := e2termConn.RmrSend(params)
 357         if snderr != nil {
 358                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 359         }
 360 }
 361
 362 //-----------------------------------------------------------------------------
 363 //
 364 //-----------------------------------------------------------------------------
 365 func (e2termConn *testingE2termControl) handle_e2term_subs_fail(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
 366         xapp.Logger.Info("(%s) handle_e2term_subs_fail", e2termConn.desc)
 367         e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
 368
 369         //---------------------------------
 370         // e2term activity: Send Subs Fail
 371         //---------------------------------
 372         xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.desc)
 373
 374         resp := &e2ap.E2APSubscriptionFailure{}
 375         resp.RequestId.Id = req.RequestId.Id
 376         resp.RequestId.Seq = req.RequestId.Seq
 377         resp.FunctionId = req.FunctionId
 378
 379         resp.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(resp.ActionNotAdmittedList.Items))
 380         for index := int(0); index < len(resp.ActionNotAdmittedList.Items); index++ {
 381                 resp.ActionNotAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
 382                 resp.ActionNotAdmittedList.Items[index].Cause.Content = 3  // CauseMisc
 383                 resp.ActionNotAdmittedList.Items[index].Cause.CauseVal = 4 // unspecified
 384         }
 385
 386         e2SubsFail.Set(resp)
 387         xapp.Logger.Debug("%s", e2SubsFail.String())
 388         packerr, packedMsg := e2SubsFail.Pack(nil)
 389         if packerr != nil {
 390                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 391         }
 392
 393         params := &RMRParams{&xapp.RMRParams{}}
 394         params.Mtype = xapp.RIC_SUB_FAILURE
 395         params.SubId = msg.SubId
 396         params.Payload = packedMsg.Buf
 397         params.Meid = msg.Meid
 398         params.Xid = msg.Xid
 399         params.Mbuf = nil
 400
 401         snderr := e2termConn.RmrSend(params)
 402         if snderr != nil {
 403                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 404         }
 405 }
 406
 407 //-----------------------------------------------------------------------------
 408 //
 409 //-----------------------------------------------------------------------------
 410 func (e2termConn *testingE2termControl) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *RMRParams) {
 411         xapp.Logger.Info("(%s) handle_e2term_subs_del_req", e2termConn.desc)
 412         e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
 413
 414         //---------------------------------
 415         // e2term activity: Recv Subs Del Req
 416         //---------------------------------
 417         select {
 418         case msg := <-e2termConn.rmrConChan:
 419                 e2termConn.DecMsgCnt()
 420                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
 421                         testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 422                 } else {
 423                         xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
 424
 425                         packedData := &packer.PackedData{}
 426                         packedData.Buf = msg.Payload
 427                         unpackerr := e2SubsDelReq.UnPack(packedData)
 428                         if unpackerr != nil {
 429                                 testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
 430                         }
 431                         geterr, req := e2SubsDelReq.Get()
 432                         if geterr != nil {
 433                                 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 434                         }
 435                         return req, msg
 436                 }
 437         case <-time.After(15 * time.Second):
 438                 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
 439         }
 440         return nil, nil
 441 }
 442
 443 func handle_e2term_recv_empty() bool {
 444         if len(e2termConn.rmrConChan) > 0 {
 445                 return false
 446         }
 447         return true
 448 }
 449
 450 func (e2termConn *testingE2termControl) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
 451         xapp.Logger.Info("(%s) handle_e2term_subs_del_resp", e2termConn.desc)
 452         e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
 453
 454         //---------------------------------
 455         // e2term activity: Send Subs Del Resp
 456         //---------------------------------
 457         xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
 458
 459         resp := &e2ap.E2APSubscriptionDeleteResponse{}
 460         resp.RequestId.Id = req.RequestId.Id
 461         resp.RequestId.Seq = req.RequestId.Seq
 462         resp.FunctionId = req.FunctionId
 463
 464         e2SubsDelResp.Set(resp)
 465         xapp.Logger.Debug("%s", e2SubsDelResp.String())
 466         packerr, packedMsg := e2SubsDelResp.Pack(nil)
 467         if packerr != nil {
 468                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 469         }
 470
 471         params := &RMRParams{&xapp.RMRParams{}}
 472         params.Mtype = xapp.RIC_SUB_DEL_RESP
 473         params.SubId = msg.SubId
 474         params.Payload = packedMsg.Buf
 475         params.Meid = msg.Meid
 476         params.Xid = msg.Xid
 477         params.Mbuf = nil
 478
 479         snderr := e2termConn.RmrSend(params)
 480         if snderr != nil {
 481                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 482         }
 483 }
 484
 485 //-----------------------------------------------------------------------------
 486 //
 487 //-----------------------------------------------------------------------------
 488 func (e2termConn *testingE2termControl) handle_e2term_subs_del_fail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
 489         xapp.Logger.Info("(%s) handle_e2term_del_subs_fail", e2termConn.desc)
 490         e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
 491
 492         //---------------------------------
 493         // e2term activity: Send Subs Del Fail
 494         //---------------------------------
 495         xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.desc)
 496
 497         resp := &e2ap.E2APSubscriptionDeleteFailure{}
 498         resp.RequestId.Id = req.RequestId.Id
 499         resp.RequestId.Seq = req.RequestId.Seq
 500         resp.FunctionId = req.FunctionId
 501         resp.Cause.Content = 3  // CauseMisc
 502         resp.Cause.CauseVal = 4 // unspecified
 503
 504         e2SubsDelFail.Set(resp)
 505         xapp.Logger.Debug("%s", e2SubsDelFail.String())
 506         packerr, packedMsg := e2SubsDelFail.Pack(nil)
 507         if packerr != nil {
 508                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 509         }
 510
 511         params := &RMRParams{&xapp.RMRParams{}}
 512         params.Mtype = xapp.RIC_SUB_DEL_FAILURE
 513         params.SubId = msg.SubId
 514         params.Payload = packedMsg.Buf
 515         params.Meid = msg.Meid
 516         params.Xid = msg.Xid
 517         params.Mbuf = nil
 518
 519         snderr := e2termConn.RmrSend(params)
 520         if snderr != nil {
 521                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 522         }
 523 }
 524
 525 //-----------------------------------------------------------------------------
 526 //
 527 //-----------------------------------------------------------------------------
 528 func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool {
 529         var subs *Subscription
 530         i := 1
 531         for ; i <= secs*2; i++ {
 532                 subs = mc.c.registry.GetSubscription(uint16(e2SubsId))
 533                 if subs == nil {
 534                         return true
 535                 }
 536                 time.Sleep(500 * time.Millisecond)
 537         }
 538         if subs != nil {
 539                 testError(t, "(general) no clean within %d secs: %s", secs, subs.String())
 540         } else {
 541                 testError(t, "(general) no clean within %d secs: subs(N/A)", secs)
 542         }
 543         return false
 544 }
 545
 546 func (mc *testingMainControl) wait_subs_trans_clean(t *testing.T, e2SubsId int, secs int) bool {
 547         var trans *Transaction
 548         i := 1
 549         for ; i <= secs*2; i++ {
 550                 subs := mc.c.registry.GetSubscription(uint16(e2SubsId))
 551                 if subs == nil {
 552                         return true
 553                 }
 554                 trans = subs.GetTransaction()
 555                 if trans == nil {
 556                         return true
 557                 }
 558                 time.Sleep(500 * time.Millisecond)
 559         }
 560         if trans != nil {
 561                 testError(t, "(general) no clean within %d secs: %s", secs, trans.String())
 562         } else {
 563                 testError(t, "(general) no clean within %d secs: trans(N/A)", secs)
 564         }
 565         return false
 566 }
 567
 568 func (mc *testingMainControl) get_subid(t *testing.T) uint16 {
 569         mc.c.registry.mutex.Lock()
 570         defer mc.c.registry.mutex.Unlock()
 571         return mc.c.registry.subIds[0]
 572 }
 573
 574 func (mc *testingMainControl) wait_subid_change(t *testing.T, origSubId uint16, secs int) (uint16, bool) {
 575         i := 1
 576         for ; i <= secs*2; i++ {
 577                 mc.c.registry.mutex.Lock()
 578                 currSubId := mc.c.registry.subIds[0]
 579                 mc.c.registry.mutex.Unlock()
 580                 if currSubId != origSubId {
 581                         return currSubId, true
 582                 }
 583                 time.Sleep(500 * time.Millisecond)
 584         }
 585         testError(t, "(general) no subId change within %d secs", secs)
 586         return 0, false
 587 }
 588
 589 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
 590         return mc.c.msgCounter
 591 }
 592
 593 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
 594         i := 1
 595         for ; i <= secs*2; i++ {
 596                 curr := mc.c.msgCounter
 597                 if curr != orig {
 598                         return curr, true
 599                 }
 600                 time.Sleep(500 * time.Millisecond)
 601         }
 602         testError(t, "(general) no msg counter change within %d secs", secs)
 603         return 0, false
 604 }
 605
 606 //-----------------------------------------------------------------------------
 607 // TestSubReqAndRouteNok
 608 //
 609 //   stub                          stub
 610 // +-------+     +---------+    +---------+
 611 // | xapp  |     | submgr  |    | rtmgr   |
 612 // +-------+     +---------+    +---------+
 613 //     |              |              |
 614 //     | SubReq       |              |
 615 //     |------------->|              |
 616 //     |              |              |
 617 //     |              | RouteCreate  |
 618 //     |              |------------->|
 619 //     |              |              |
 620 //     |              | RouteCreate  |
 621 //     |              |  status:400  |
 622 //     |              |<-------------|
 623 //     |              |              |
 624 //     |       [SUBS INT DELETE]     |
 625 //     |              |              |
 626 //
 627 //-----------------------------------------------------------------------------
 628
 629 func TestSubReqAndRouteNok(t *testing.T) {
 630         xapp.Logger.Info("TestSubReqAndRouteNok")
 631
 632         waiter := rtmgrHttp.AllocNextEvent(false)
 633         newSubsId := mainCtrl.get_subid(t)
 634         xappConn1.handle_xapp_subs_req(t, nil)
 635         waiter.WaitResult(t)
 636
 637         //Wait that subs is cleaned
 638         mainCtrl.wait_subs_clean(t, int(newSubsId), 10)
 639
 640         xappConn1.TestMsgCnt(t)
 641         xappConn2.TestMsgCnt(t)
 642         e2termConn.TestMsgCnt(t)
 643 }
 644
 645 //-----------------------------------------------------------------------------
 646 // TestSubReqAndSubDelOk
 647 //
 648 //   stub                          stub
 649 // +-------+     +---------+    +---------+
 650 // | xapp  |     | submgr  |    | e2term  |
 651 // +-------+     +---------+    +---------+
 652 //     |              |              |
 653 //     | SubReq       |              |
 654 //     |------------->|              |
 655 //     |              |              |
 656 //     |              | SubReq       |
 657 //     |              |------------->|
 658 //     |              |              |
 659 //     |              |      SubResp |
 660 //     |              |<-------------|
 661 //     |              |              |
 662 //     |      SubResp |              |
 663 //     |<-------------|              |
 664 //     |              |              |
 665 //     |              |              |
 666 //     | SubDelReq    |              |
 667 //     |------------->|              |
 668 //     |              |              |
 669 //     |              | SubDelReq    |
 670 //     |              |------------->|
 671 //     |              |              |
 672 //     |              |   SubDelResp |
 673 //     |              |<-------------|
 674 //     |              |              |
 675 //     |   SubDelResp |              |
 676 //     |<-------------|              |
 677 //
 678 //-----------------------------------------------------------------------------
 679 func TestSubReqAndSubDelOk(t *testing.T) {
 680         xapp.Logger.Info("TestSubReqAndSubDelOk")
 681
 682         waiter := rtmgrHttp.AllocNextEvent(true)
 683         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 684         waiter.WaitResult(t)
 685
 686         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 687         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 688         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 689         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 690         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 691
 692         waiter = rtmgrHttp.AllocNextEvent(true)
 693         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 694         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 695         waiter.WaitResult(t)
 696
 697         //Wait that subs is cleaned
 698         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 699
 700         xappConn1.TestMsgCnt(t)
 701         xappConn2.TestMsgCnt(t)
 702         e2termConn.TestMsgCnt(t)
 703 }
 704
 705 //-----------------------------------------------------------------------------
 706 // TestSubReqRetransmission
 707 //
 708 //   stub                          stub
 709 // +-------+     +---------+    +---------+
 710 // | xapp  |     | submgr  |    | e2term  |
 711 // +-------+     +---------+    +---------+
 712 //     |              |              |
 713 //     |  SubReq      |              |
 714 //     |------------->|              |
 715 //     |              |              |
 716 //     |              | SubReq       |
 717 //     |              |------------->|
 718 //     |              |              |
 719 //     |  SubReq      |              |
 720 //     | (retrans)    |              |
 721 //     |------------->|              |
 722 //     |              |              |
 723 //     |              |      SubResp |
 724 //     |              |<-------------|
 725 //     |              |              |
 726 //     |      SubResp |              |
 727 //     |<-------------|              |
 728 //     |              |              |
 729 //     |         [SUBS DELETE]       |
 730 //     |              |              |
 731 //
 732 //-----------------------------------------------------------------------------
 733 func TestSubReqRetransmission(t *testing.T) {
 734         xapp.Logger.Info("TestSubReqRetransmission")
 735
 736         //Subs Create
 737         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 738         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 739
 740         seqBef := mainCtrl.get_msgcounter(t)
 741         xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
 742         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 743
 744         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 745         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 746
 747         //Subs Delete
 748         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 749         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 750         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 751         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 752
 753         //Wait that subs is cleaned
 754         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 755
 756         xappConn1.TestMsgCnt(t)
 757         xappConn2.TestMsgCnt(t)
 758         e2termConn.TestMsgCnt(t)
 759 }
 760
 761 //-----------------------------------------------------------------------------
 762 // TestSubDelReqRetransmission
 763 //
 764 //   stub                          stub
 765 // +-------+     +---------+    +---------+
 766 // | xapp  |     | submgr  |    | e2term  |
 767 // +-------+     +---------+    +---------+
 768 //     |              |              |
 769 //     |         [SUBS CREATE]       |
 770 //     |              |              |
 771 //     |              |              |
 772 //     | SubDelReq    |              |
 773 //     |------------->|              |
 774 //     |              |              |
 775 //     |              | SubDelReq    |
 776 //     |              |------------->|
 777 //     |              |              |
 778 //     | SubDelReq    |              |
 779 //     | (same sub)   |              |
 780 //     | (same xid)   |              |
 781 //     |------------->|              |
 782 //     |              |              |
 783 //     |              |   SubDelResp |
 784 //     |              |<-------------|
 785 //     |              |              |
 786 //     |   SubDelResp |              |
 787 //     |<-------------|              |
 788 //
 789 //-----------------------------------------------------------------------------
 790 func TestSubDelReqRetransmission(t *testing.T) {
 791         xapp.Logger.Info("TestSubDelReqRetransmission")
 792
 793         //Subs Create
 794         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 795         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 796         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 797         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 798
 799         //Subs Delete
 800         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 801         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 802
 803         seqBef := mainCtrl.get_msgcounter(t)
 804         xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
 805         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 806
 807         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 808         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 809
 810         //Wait that subs is cleaned
 811         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 812
 813         xappConn1.TestMsgCnt(t)
 814         xappConn2.TestMsgCnt(t)
 815         e2termConn.TestMsgCnt(t)
 816 }
 817
 818 //-----------------------------------------------------------------------------
 819 // TestSubDelReqCollision
 820 //
 821 //   stub                          stub
 822 // +-------+     +---------+    +---------+
 823 // | xapp  |     | submgr  |    | e2term  |
 824 // +-------+     +---------+    +---------+
 825 //     |              |              |
 826 //     |         [SUBS CREATE]       |
 827 //     |              |              |
 828 //     |              |              |
 829 //     | SubDelReq    |              |
 830 //     |------------->|              |
 831 //     |              |              |
 832 //     |              | SubDelReq    |
 833 //     |              |------------->|
 834 //     |              |              |
 835 //     | SubDelReq    |              |
 836 //     | (same sub)   |              |
 837 //     | (diff xid)   |              |
 838 //     |------------->|              |
 839 //     |              |              |
 840 //     |              |   SubDelResp |
 841 //     |              |<-------------|
 842 //     |              |              |
 843 //     |   SubDelResp |              |
 844 //     |<-------------|              |
 845 //
 846 //-----------------------------------------------------------------------------
 847 func TestSubDelReqCollision(t *testing.T) {
 848         xapp.Logger.Info("TestSubDelReqCollision")
 849
 850         //Subs Create
 851         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 852         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 853         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 854         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 855
 856         //Subs Delete
 857         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 858         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 859
 860         seqBef := mainCtrl.get_msgcounter(t)
 861         deltranscol := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 862         xappConn1.handle_xapp_subs_del_req(t, deltranscol, e2SubsId) //Colliding SubDelReq
 863         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 864
 865         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 866         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 867
 868         //Wait that subs is cleaned
 869         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 870
 871         xappConn1.TestMsgCnt(t)
 872         xappConn2.TestMsgCnt(t)
 873         e2termConn.TestMsgCnt(t)
 874 }
 875
 876 //-----------------------------------------------------------------------------
 877 // TestSubReqAndSubDelOkTwoParallel
 878 //
 879 //   stub                          stub
 880 // +-------+     +---------+    +---------+
 881 // | xapp  |     | submgr  |    | e2term  |
 882 // +-------+     +---------+    +---------+
 883 //     |              |              |
 884 //     |              |              |
 885 //     |              |              |
 886 //     | SubReq1      |              |
 887 //     |------------->|              |
 888 //     |              |              |
 889 //     |              | SubReq1      |
 890 //     |              |------------->|
 891 //     |              |              |
 892 //     | SubReq2      |              |
 893 //     |------------->|              |
 894 //     |              |              |
 895 //     |              | SubReq2      |
 896 //     |              |------------->|
 897 //     |              |              |
 898 //     |              |    SubResp1  |
 899 //     |              |<-------------|
 900 //     |              |    SubResp2  |
 901 //     |              |<-------------|
 902 //     |              |              |
 903 //     |    SubResp1  |              |
 904 //     |<-------------|              |
 905 //     |    SubResp2  |              |
 906 //     |<-------------|              |
 907 //     |              |              |
 908 //     |        [SUBS 1 DELETE]      |
 909 //     |              |              |
 910 //     |        [SUBS 2 DELETE]      |
 911 //     |              |              |
 912 //
 913 //-----------------------------------------------------------------------------
 914 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
 915         xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
 916
 917         //Req1
 918         cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
 919         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 920
 921         //Req2
 922         cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
 923         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 924
 925         //Resp1
 926         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 927         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 928
 929         //Resp2
 930         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 931         e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
 932
 933         //Del1
 934         deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
 935         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 936         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 937         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 938         //Wait that subs is cleaned
 939         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 940
 941         //Del2
 942         deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
 943         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 944         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 945         xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
 946         //Wait that subs is cleaned
 947         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 948
 949         xappConn1.TestMsgCnt(t)
 950         xappConn2.TestMsgCnt(t)
 951         e2termConn.TestMsgCnt(t)
 952 }
 953
 954 //-----------------------------------------------------------------------------
 955 // TestSameSubsDiffRan
 956 // Same subscription to different RANs
 957 //
 958 //   stub                          stub
 959 // +-------+     +---------+    +---------+
 960 // | xapp  |     | submgr  |    | e2term  |
 961 // +-------+     +---------+    +---------+
 962 //     |              |              |
 963 //     |              |              |
 964 //     |              |              |
 965 //     | SubReq(r1)   |              |
 966 //     |------------->|              |
 967 //     |              |              |
 968 //     |              | SubReq(r1)   |
 969 //     |              |------------->|
 970 //     |              |              |
 971 //     |              | SubResp(r1)  |
 972 //     |              |<-------------|
 973 //     |              |              |
 974 //     | SubResp(r1)  |              |
 975 //     |<-------------|              |
 976 //     |              |              |
 977 //     | SubReq(r2)   |              |
 978 //     |------------->|              |
 979 //     |              |              |
 980 //     |              | SubReq(r2)   |
 981 //     |              |------------->|
 982 //     |              |              |
 983 //     |              | SubResp(r2)  |
 984 //     |              |<-------------|
 985 //     |              |              |
 986 //     | SubResp(r2)  |              |
 987 //     |<-------------|              |
 988 //     |              |              |
 989 //     |       [SUBS r1 DELETE]      |
 990 //     |              |              |
 991 //     |       [SUBS r2 DELETE]      |
 992 //     |              |              |
 993 //
 994 //-----------------------------------------------------------------------------
 995 func TestSameSubsDiffRan(t *testing.T) {
 996         xapp.Logger.Info("TestSameSubsDiffRan")
 997
 998         //Req1
 999         cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
1000         xappConn1.handle_xapp_subs_req(t, cretrans1)
1001         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
1002         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
1003         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
1004
1005         //Req2
1006         cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
1007         xappConn1.handle_xapp_subs_req(t, cretrans2)
1008         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
1009         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
1010         e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
1011
1012         //Del1
1013         deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
1014         xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
1015         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
1016         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
1017         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
1018         //Wait that subs is cleaned
1019         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1020
1021         //Del2
1022         deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
1023         xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
1024         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
1025         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
1026         xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
1027         //Wait that subs is cleaned
1028         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1029
1030         xappConn1.TestMsgCnt(t)
1031         xappConn2.TestMsgCnt(t)
1032         e2termConn.TestMsgCnt(t)
1033 }
1034
1035 //-----------------------------------------------------------------------------
1036 // TestSubReqRetryInSubmgr
1037 //
1038 //   stub                          stub
1039 // +-------+     +---------+    +---------+
1040 // | xapp  |     | submgr  |    | e2term  |
1041 // +-------+     +---------+    +---------+
1042 //     |              |              |
1043 //     |  SubReq      |              |
1044 //     |------------->|              |
1045 //     |              |              |
1046 //     |              | SubReq       |
1047 //     |              |------------->|
1048 //     |              |              |
1049 //     |              |              |
1050 //     |              | SubReq       |
1051 //     |              |------------->|
1052 //     |              |              |
1053 //     |              |      SubResp |
1054 //     |              |<-------------|
1055 //     |              |              |
1056 //     |      SubResp |              |
1057 //     |<-------------|              |
1058 //     |              |              |
1059 //     |         [SUBS DELETE]       |
1060 //     |              |              |
1061 //
1062 //-----------------------------------------------------------------------------
1063
1064 func TestSubReqRetryInSubmgr(t *testing.T) {
1065
1066         xapp.Logger.Info("TestSubReqRetryInSubmgr start")
1067
1068         // Xapp: Send SubsReq
1069         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1070
1071         // E2t: Receive 1st SubsReq
1072         e2termConn.handle_e2term_subs_req(t)
1073
1074         // E2t: Receive 2nd SubsReq and send SubsResp
1075         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1076         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1077
1078         // Xapp: Receive SubsResp
1079         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1080
1081         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1082         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1083         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1084         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1085
1086         // Wait that subs is cleaned
1087         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1088
1089         xappConn1.TestMsgCnt(t)
1090         xappConn2.TestMsgCnt(t)
1091         e2termConn.TestMsgCnt(t)
1092 }
1093
1094 //-----------------------------------------------------------------------------
1095 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1096 //
1097 //   stub                          stub
1098 // +-------+     +---------+    +---------+
1099 // | xapp  |     | submgr  |    | e2term  |
1100 // +-------+     +---------+    +---------+
1101 //     |              |              |
1102 //     |  SubReq      |              |
1103 //     |------------->|              |
1104 //     |              |              |
1105 //     |              | SubReq       |
1106 //     |              |------------->|
1107 //     |              |              |
1108 //     |              |              |
1109 //     |              | SubReq       |
1110 //     |              |------------->|
1111 //     |              |              |
1112 //     |              | SubDelReq    |
1113 //     |              |------------->|
1114 //     |              |              |
1115 //     |              |              |
1116 //     |              | SubDelReq    |
1117 //     |              |------------->|
1118 //     |              |              |
1119 //     |              |              |
1120 //     |              |   SubDelResp |
1121 //     |              |<-------------|
1122 //     |              |              |
1123 //
1124 //-----------------------------------------------------------------------------
1125
1126 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1127
1128         xapp.Logger.Info("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1129
1130         // Xapp: Send SubsReq
1131         xappConn1.handle_xapp_subs_req(t, nil)
1132
1133         // E2t: Receive 1st SubsReq
1134         e2termConn.handle_e2term_subs_req(t)
1135
1136         // E2t: Receive 2nd SubsReq
1137         e2termConn.handle_e2term_subs_req(t)
1138
1139         // E2t: Send receive SubsDelReq and send SubsResp
1140         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1141         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1142
1143         // Wait that subs is cleaned
1144         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1145
1146         xappConn1.TestMsgCnt(t)
1147         xappConn2.TestMsgCnt(t)
1148         e2termConn.TestMsgCnt(t)
1149 }
1150
1151 //-----------------------------------------------------------------------------
1152 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1153 //
1154 //   stub                          stub
1155 // +-------+     +---------+    +---------+
1156 // | xapp  |     | submgr  |    | e2term  |
1157 // +-------+     +---------+    +---------+
1158 //     |              |              |
1159 //     |  SubReq      |              |
1160 //     |------------->|              |
1161 //     |              |              |
1162 //     |              | SubReq       |
1163 //     |              |------------->|
1164 //     |              |              |
1165 //     |              |              |
1166 //     |              | SubReq       |
1167 //     |              |------------->|
1168 //     |              |              |
1169 //     |              | SubDelReq    |
1170 //     |              |------------->|
1171 //     |              |              |
1172 //     |              |              |
1173 //     |              | SubDelReq    |
1174 //     |              |------------->|
1175 //     |              |              |
1176 //     |              |              |
1177 //
1178 //-----------------------------------------------------------------------------
1179
1180 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1181
1182         xapp.Logger.Info("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1183
1184         // Xapp: Send SubsReq
1185         xappConn1.handle_xapp_subs_req(t, nil)
1186
1187         // E2t: Receive 1st SubsReq
1188         e2termConn.handle_e2term_subs_req(t)
1189
1190         // E2t: Receive 2nd SubsReq
1191         e2termConn.handle_e2term_subs_req(t)
1192
1193         // E2t: Receive 1st SubsDelReq
1194         e2termConn.handle_e2term_subs_del_req(t)
1195
1196         // E2t: Receive 2nd SubsDelReq
1197         delreq, _ := e2termConn.handle_e2term_subs_del_req(t)
1198
1199         // Wait that subs is cleaned
1200         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 15)
1201
1202         xappConn1.TestMsgCnt(t)
1203         xappConn2.TestMsgCnt(t)
1204         e2termConn.TestMsgCnt(t)
1205 }
1206
1207 //-----------------------------------------------------------------------------
1208 // TestSubReqSubFailRespInSubmgr
1209 //
1210 //   stub                          stub
1211 // +-------+     +---------+    +---------+
1212 // | xapp  |     | submgr  |    | e2term  |
1213 // +-------+     +---------+    +---------+
1214 //     |              |              |
1215 //     |  SubReq      |              |
1216 //     |------------->|              |
1217 //     |              |              |
1218 //     |              | SubReq       |
1219 //     |              |------------->|
1220 //     |              |              |
1221 //     |              |      SubFail |
1222 //     |              |<-------------|
1223 //     |              |              |
1224 //     |      SubFail |              |
1225 //     |<-------------|              |
1226 //     |              |              |
1227 //
1228 //-----------------------------------------------------------------------------
1229
1230 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1231
1232         xapp.Logger.Info("TestSubReqSubFailRespInSubmgr start")
1233
1234         // Xapp: Send SubsReq
1235         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1236
1237         // E2t: Receive SubsReq and send SubsFail
1238         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1239         e2termConn.handle_e2term_subs_fail(t, crereq, cremsg)
1240
1241         // Xapp: Receive SubsFail
1242         e2SubsId := xappConn1.handle_xapp_subs_fail(t, cretrans)
1243
1244         // Wait that subs is cleaned
1245         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1246
1247         xappConn1.TestMsgCnt(t)
1248         xappConn2.TestMsgCnt(t)
1249         e2termConn.TestMsgCnt(t)
1250 }
1251
1252 //-----------------------------------------------------------------------------
1253 // TestSubDelReqRetryInSubmgr
1254 //
1255 //   stub                          stub
1256 // +-------+     +---------+    +---------+
1257 // | xapp  |     | submgr  |    | e2term  |
1258 // +-------+     +---------+    +---------+
1259 //     |              |              |
1260 //     |         [SUBS CREATE]       |
1261 //     |              |              |
1262 //     |              |              |
1263 //     | SubDelReq    |              |
1264 //     |------------->|              |
1265 //     |              |              |
1266 //     |              | SubDelReq    |
1267 //     |              |------------->|
1268 //     |              |              |
1269 //     |              | SubDelReq    |
1270 //     |              |------------->|
1271 //     |              |              |
1272 //     |              |   SubDelResp |
1273 //     |              |<-------------|
1274 //     |              |              |
1275 //     |   SubDelResp |              |
1276 //     |<-------------|              |
1277 //
1278 //-----------------------------------------------------------------------------
1279
1280 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1281
1282         xapp.Logger.Info("TestSubDelReqRetryInSubmgr start")
1283
1284         // Subs Create
1285         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1286         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1287         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1288         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1289
1290         // Subs Delete
1291         // Xapp: Send SubsDelReq
1292         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1293
1294         // E2t: Receive 1st SubsDelReq
1295         e2termConn.handle_e2term_subs_del_req(t)
1296
1297         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1298         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1299         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1300
1301         // Xapp: Receive SubsDelResp
1302         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1303
1304         // Wait that subs is cleaned
1305         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1306
1307         xappConn1.TestMsgCnt(t)
1308         xappConn2.TestMsgCnt(t)
1309         e2termConn.TestMsgCnt(t)
1310 }
1311
1312 //-----------------------------------------------------------------------------
1313 // TestSubDelReqTwoRetriesNoRespInSubmgr
1314 //
1315 //   stub                          stub
1316 // +-------+     +---------+    +---------+
1317 // | xapp  |     | submgr  |    | e2term  |
1318 // +-------+     +---------+    +---------+
1319 //     |              |              |
1320 //     |         [SUBS CREATE]       |
1321 //     |              |              |
1322 //     |              |              |
1323 //     | SubDelReq    |              |
1324 //     |------------->|              |
1325 //     |              |              |
1326 //     |              | SubDelReq    |
1327 //     |              |------------->|
1328 //     |              |              |
1329 //     |              | SubDelReq    |
1330 //     |              |------------->|
1331 //     |              |              |
1332 //     |              |              |
1333 //     |   SubDelResp |              |
1334 //     |<-------------|              |
1335 //
1336 //-----------------------------------------------------------------------------
1337
1338 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1339
1340         xapp.Logger.Info("TestSubDelReTwoRetriesNoRespInSubmgr start")
1341
1342         // Subs Create
1343         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1344         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1345         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1346         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1347
1348         // Subs Delete
1349         // Xapp: Send SubsDelReq
1350         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1351
1352         // E2t: Receive 1st SubsDelReq
1353         e2termConn.handle_e2term_subs_del_req(t)
1354
1355         // E2t: Receive 2nd SubsDelReq
1356         e2termConn.handle_e2term_subs_del_req(t)
1357
1358         // Xapp: Receive SubsDelResp
1359         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1360
1361         // Wait that subs is cleaned
1362         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1363
1364         xappConn1.TestMsgCnt(t)
1365         xappConn2.TestMsgCnt(t)
1366         e2termConn.TestMsgCnt(t)
1367 }
1368
1369 //-----------------------------------------------------------------------------
1370 // TestSubDelReqSubDelFailRespInSubmgr
1371 //
1372 //   stub                          stub
1373 // +-------+     +---------+    +---------+
1374 // | xapp  |     | submgr  |    | e2term  |
1375 // +-------+     +---------+    +---------+
1376 //     |              |              |
1377 //     |         [SUBS CREATE]       |
1378 //     |              |              |
1379 //     |              |              |
1380 //     |  SubDelReq   |              |
1381 //     |------------->|              |
1382 //     |              |              |
1383 //     |              | SubDelReq    |
1384 //     |              |------------->|
1385 //     |              |              |
1386 //     |              |   SubDelFail |
1387 //     |              |<-------------|
1388 //     |              |              |
1389 //     |   SubDelResp |              |
1390 //     |<-------------|              |
1391 //     |              |              |
1392 //
1393 //-----------------------------------------------------------------------------
1394
1395 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1396
1397         xapp.Logger.Info("TestSubReqSubDelFailRespInSubmgr start")
1398
1399         // Subs Create
1400         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1401         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1402         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1403         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1404
1405         // Xapp: Send SubsDelReq
1406         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1407
1408         // E2t: Send receive SubsDelReq and send SubsDelFail
1409         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1410         e2termConn.handle_e2term_subs_del_fail(t, delreq, delmsg)
1411
1412         // Xapp: Receive SubsDelResp
1413         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1414
1415         // Wait that subs is cleaned
1416         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1417
1418         xappConn1.TestMsgCnt(t)
1419         xappConn2.TestMsgCnt(t)
1420         e2termConn.TestMsgCnt(t)
1421 }