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                 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])
 120                         return -1
 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)
 123                         return -1
 124                 } else {
 125                         packedData := &packer.PackedData{}
 126                         packedData.Buf = msg.Payload
 127                         e2SubsId = msg.SubId
 128                         unpackerr := e2SubsResp.UnPack(packedData)
 129
 130                         if unpackerr != nil {
 131                                 testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
 132                         }
 133                         geterr, resp := e2SubsResp.Get()
 134                         if geterr != nil {
 135                                 testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error())
 136                         }
 137
 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)
 139                         return e2SubsId
 140                 }
 141         case <-time.After(15 * time.Second):
 142                 testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc)
 143                 return -1
 144         }
 145         return -1
 146 }
 147
 148 //-----------------------------------------------------------------------------
 149 //
 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()
 154         var e2SubsId int
 155
 156         //-------------------------------
 157         // xapp activity: Recv Subs Fail
 158         //-------------------------------
 159         select {
 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])
 163                         return -1
 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)
 166                         return -1
 167                 } else {
 168                         packedData := &packer.PackedData{}
 169                         packedData.Buf = msg.Payload
 170                         e2SubsId = msg.SubId
 171                         unpackerr := e2SubsFail.UnPack(packedData)
 172
 173                         if unpackerr != nil {
 174                                 testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.desc, unpackerr.Error())
 175                         }
 176                         geterr, resp := e2SubsFail.Get()
 177                         if geterr != nil {
 178                                 testError(t, "(%s) RIC_SUB_FAILURE get failed err: %s", xappConn.desc, geterr.Error())
 179                         }
 180
 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)
 182                         return e2SubsId
 183                 }
 184         case <-time.After(15 * time.Second):
 185                 testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.desc)
 186                 return -1
 187         }
 188         return -1
 189 }
 190
 191 //-----------------------------------------------------------------------------
 192 //
 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()
 197
 198         //---------------------------------
 199         // xapp activity: Send Subs Del Req
 200         //---------------------------------
 201         xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
 202
 203         req := &e2ap.E2APSubscriptionDeleteRequest{}
 204         req.RequestId.Id = 1
 205         req.RequestId.Seq = uint32(e2SubsId)
 206         req.FunctionId = 1
 207
 208         e2SubsDelReq.Set(req)
 209         xapp.Logger.Debug("%s", e2SubsDelReq.String())
 210         err, packedMsg := e2SubsDelReq.Pack(nil)
 211         if err != nil {
 212                 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
 213                 return nil
 214         }
 215
 216         var trans *xappTransaction = oldTrans
 217         if trans == nil {
 218                 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
 219         }
 220
 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
 227         params.Mbuf = nil
 228
 229         snderr := xappConn.RmrSend(params)
 230         if snderr != nil {
 231                 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
 232                 return nil
 233         }
 234         return trans
 235 }
 236
 237 //-----------------------------------------------------------------------------
 238 //
 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()
 243
 244         //---------------------------------
 245         // xapp activity: Recv Subs Del Resp
 246         //---------------------------------
 247         select {
 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])
 251                         return
 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)
 254                         return
 255                 } else {
 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())
 261                         }
 262                         geterr, resp := e2SubsDelResp.Get()
 263                         if geterr != nil {
 264                                 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
 265                         }
 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)
 267                         return
 268                 }
 269         case <-time.After(15 * time.Second):
 270                 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
 271         }
 272 }
 273
 274 //-----------------------------------------------------------------------------
 275 //
 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()
 280
 281         //---------------------------------
 282         // e2term activity: Recv Subs Req
 283         //---------------------------------
 284         select {
 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])
 288                 } else {
 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())
 295                         }
 296                         geterr, req := e2SubsReq.Get()
 297                         if geterr != nil {
 298                                 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 299                         }
 300                         return req, msg
 301                 }
 302         case <-time.After(15 * time.Second):
 303                 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
 304         }
 305         return nil, nil
 306 }
 307
 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()
 311
 312         //---------------------------------
 313         // e2term activity: Send Subs Resp
 314         //---------------------------------
 315         xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
 316
 317         resp := &e2ap.E2APSubscriptionResponse{}
 318
 319         resp.RequestId.Id = req.RequestId.Id
 320         resp.RequestId.Seq = req.RequestId.Seq
 321         resp.FunctionId = req.FunctionId
 322
 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
 326         }
 327
 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)
 334         }
 335
 336         e2SubsResp.Set(resp)
 337         xapp.Logger.Debug("%s", e2SubsResp.String())
 338         packerr, packedMsg := e2SubsResp.Pack(nil)
 339         if packerr != nil {
 340                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 341         }
 342
 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
 348         params.Xid = msg.Xid
 349         params.Mbuf = nil
 350
 351         snderr := e2termConn.RmrSend(params)
 352         if snderr != nil {
 353                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 354         }
 355 }
 356
 357 //-----------------------------------------------------------------------------
 358 //
 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()
 363
 364         //---------------------------------
 365         // e2term activity: Send Subs Fail
 366         //---------------------------------
 367         xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.desc)
 368
 369         resp := &e2ap.E2APSubscriptionFailure{}
 370         resp.RequestId.Id = req.RequestId.Id
 371         resp.RequestId.Seq = req.RequestId.Seq
 372         resp.FunctionId = req.FunctionId
 373
 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
 379         }
 380
 381         e2SubsFail.Set(resp)
 382         xapp.Logger.Debug("%s", e2SubsFail.String())
 383         packerr, packedMsg := e2SubsFail.Pack(nil)
 384         if packerr != nil {
 385                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 386         }
 387
 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
 393         params.Xid = msg.Xid
 394         params.Mbuf = nil
 395
 396         snderr := e2termConn.RmrSend(params)
 397         if snderr != nil {
 398                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 399         }
 400 }
 401
 402 //-----------------------------------------------------------------------------
 403 //
 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()
 408
 409         //---------------------------------
 410         // e2term activity: Recv Subs Del Req
 411         //---------------------------------
 412         select {
 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])
 416                 } else {
 417                         xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
 418
 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())
 424                         }
 425                         geterr, req := e2SubsDelReq.Get()
 426                         if geterr != nil {
 427                                 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 428                         }
 429                         return req, msg
 430                 }
 431         case <-time.After(15 * time.Second):
 432                 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
 433         }
 434         return nil, nil
 435 }
 436
 437 func handle_e2term_recv_empty() bool {
 438         if len(e2termConn.rmrConChan) > 0 {
 439                 return false
 440         }
 441         return true
 442 }
 443
 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()
 447
 448         //---------------------------------
 449         // e2term activity: Send Subs Del Resp
 450         //---------------------------------
 451         xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
 452
 453         resp := &e2ap.E2APSubscriptionDeleteResponse{}
 454         resp.RequestId.Id = req.RequestId.Id
 455         resp.RequestId.Seq = req.RequestId.Seq
 456         resp.FunctionId = req.FunctionId
 457
 458         e2SubsDelResp.Set(resp)
 459         xapp.Logger.Debug("%s", e2SubsDelResp.String())
 460         packerr, packedMsg := e2SubsDelResp.Pack(nil)
 461         if packerr != nil {
 462                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 463         }
 464
 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
 470         params.Xid = msg.Xid
 471         params.Mbuf = nil
 472
 473         snderr := e2termConn.RmrSend(params)
 474         if snderr != nil {
 475                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 476         }
 477 }
 478
 479 //-----------------------------------------------------------------------------
 480 //
 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()
 485
 486         //---------------------------------
 487         // e2term activity: Send Subs Del Fail
 488         //---------------------------------
 489         xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.desc)
 490
 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
 497
 498         e2SubsDelFail.Set(resp)
 499         xapp.Logger.Debug("%s", e2SubsDelFail.String())
 500         packerr, packedMsg := e2SubsDelFail.Pack(nil)
 501         if packerr != nil {
 502                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 503         }
 504
 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
 510         params.Xid = msg.Xid
 511         params.Mbuf = nil
 512
 513         snderr := e2termConn.RmrSend(params)
 514         if snderr != nil {
 515                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 516         }
 517 }
 518
 519 //-----------------------------------------------------------------------------
 520 //
 521 //-----------------------------------------------------------------------------
 522 func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool {
 523         i := 1
 524         for ; i <= secs*2; i++ {
 525                 if mc.c.registry.GetSubscription(uint16(e2SubsId)) == nil {
 526                         return true
 527                 }
 528                 time.Sleep(500 * time.Millisecond)
 529         }
 530         testError(t, "(general) no clean within %d secs", secs)
 531         return false
 532 }
 533
 534 func (mc *testingMainControl) wait_subs_trans_clean(t *testing.T, e2SubsId int, secs int) bool {
 535         i := 1
 536         for ; i <= secs*2; i++ {
 537                 subs := mc.c.registry.GetSubscription(uint16(e2SubsId))
 538                 if subs == nil {
 539                         return true
 540                 }
 541                 trans := subs.GetTransaction()
 542                 if trans == nil {
 543                         return true
 544                 }
 545                 time.Sleep(500 * time.Millisecond)
 546         }
 547         testError(t, "(general) no clean within %d secs", secs)
 548         return false
 549 }
 550
 551 func (mc *testingMainControl) get_subid(t *testing.T) uint16 {
 552         mc.c.registry.mutex.Lock()
 553         defer mc.c.registry.mutex.Unlock()
 554         return mc.c.registry.subIds[0]
 555 }
 556
 557 func (mc *testingMainControl) wait_subid_change(t *testing.T, origSubId uint16, secs int) (uint16, bool) {
 558         i := 1
 559         for ; i <= secs*2; i++ {
 560                 mc.c.registry.mutex.Lock()
 561                 currSubId := mc.c.registry.subIds[0]
 562                 mc.c.registry.mutex.Unlock()
 563                 if currSubId != origSubId {
 564                         return currSubId, true
 565                 }
 566                 time.Sleep(500 * time.Millisecond)
 567         }
 568         testError(t, "(general) no subId change within %d secs", secs)
 569         return 0, false
 570 }
 571
 572 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
 573         return mc.c.msgCounter
 574 }
 575
 576 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
 577         i := 1
 578         for ; i <= secs*2; i++ {
 579                 curr := mc.c.msgCounter
 580                 if curr != orig {
 581                         return curr, true
 582                 }
 583                 time.Sleep(500 * time.Millisecond)
 584         }
 585         testError(t, "(general) no msg counter change within %d secs", secs)
 586         return 0, false
 587 }
 588
 589 //-----------------------------------------------------------------------------
 590 // TestSubReqAndSubDelOk
 591 //
 592 //   stub                          stub
 593 // +-------+     +---------+    +---------+
 594 // | xapp  |     | submgr  |    | e2term  |
 595 // +-------+     +---------+    +---------+
 596 //     |              |              |
 597 //     | SubReq       |              |
 598 //     |------------->|              |
 599 //     |              |              |
 600 //     |              | SubReq       |
 601 //     |              |------------->|
 602 //     |              |              |
 603 //     |              |      SubResp |
 604 //     |              |<-------------|
 605 //     |              |              |
 606 //     |      SubResp |              |
 607 //     |<-------------|              |
 608 //     |              |              |
 609 //     |              |              |
 610 //     | SubDelReq    |              |
 611 //     |------------->|              |
 612 //     |              |              |
 613 //     |              | SubDelReq    |
 614 //     |              |------------->|
 615 //     |              |              |
 616 //     |              |   SubDelResp |
 617 //     |              |<-------------|
 618 //     |              |              |
 619 //     |   SubDelResp |              |
 620 //     |<-------------|              |
 621 //
 622 //-----------------------------------------------------------------------------
 623 func TestSubReqAndSubDelOk(t *testing.T) {
 624         xapp.Logger.Info("TestSubReqAndSubDelOk")
 625         rtmgrHttp.UseChannel(true)
 626
 627         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 628         msg := rtmgrHttp.WaitReq(t)
 629         msg.RetOk()
 630         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 631         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 632         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 633
 634         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 635         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 636         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 637         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 638
 639         msg = rtmgrHttp.WaitReq(t)
 640         msg.RetOk()
 641
 642         //Wait that subs is cleaned
 643         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 644         rtmgrHttp.UseChannel(false)
 645 }
 646
 647 //-----------------------------------------------------------------------------
 648 // TestSubReqRetransmission
 649 //
 650 //   stub                          stub
 651 // +-------+     +---------+    +---------+
 652 // | xapp  |     | submgr  |    | e2term  |
 653 // +-------+     +---------+    +---------+
 654 //     |              |              |
 655 //     |  SubReq      |              |
 656 //     |------------->|              |
 657 //     |              |              |
 658 //     |              | SubReq       |
 659 //     |              |------------->|
 660 //     |              |              |
 661 //     |  SubReq      |              |
 662 //     | (retrans)    |              |
 663 //     |------------->|              |
 664 //     |              |              |
 665 //     |              |      SubResp |
 666 //     |              |<-------------|
 667 //     |              |              |
 668 //     |      SubResp |              |
 669 //     |<-------------|              |
 670 //     |              |              |
 671 //     |         [SUBS DELETE]       |
 672 //     |              |              |
 673 //
 674 //-----------------------------------------------------------------------------
 675 func TestSubReqRetransmission(t *testing.T) {
 676         xapp.Logger.Info("TestSubReqRetransmission")
 677
 678         //Subs Create
 679         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 680         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 681
 682         seqBef := mainCtrl.get_msgcounter(t)
 683         xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
 684         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 685
 686         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 687         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 688
 689         //Subs Delete
 690         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 691         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 692         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 693         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 694
 695         //Wait that subs is cleaned
 696         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 697 }
 698
 699 //-----------------------------------------------------------------------------
 700 // TestSubDelReqRetransmission
 701 //
 702 //   stub                          stub
 703 // +-------+     +---------+    +---------+
 704 // | xapp  |     | submgr  |    | e2term  |
 705 // +-------+     +---------+    +---------+
 706 //     |              |              |
 707 //     |         [SUBS CREATE]       |
 708 //     |              |              |
 709 //     |              |              |
 710 //     | SubDelReq    |              |
 711 //     |------------->|              |
 712 //     |              |              |
 713 //     |              | SubDelReq    |
 714 //     |              |------------->|
 715 //     |              |              |
 716 //     | SubDelReq    |              |
 717 //     | (same sub)   |              |
 718 //     | (same xid)   |              |
 719 //     |------------->|              |
 720 //     |              |              |
 721 //     |              |   SubDelResp |
 722 //     |              |<-------------|
 723 //     |              |              |
 724 //     |   SubDelResp |              |
 725 //     |<-------------|              |
 726 //
 727 //-----------------------------------------------------------------------------
 728 func TestSubDelReqRetransmission(t *testing.T) {
 729         xapp.Logger.Info("TestSubDelReqRetransmission")
 730
 731         //Subs Create
 732         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 733         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 734         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 735         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 736
 737         //Subs Delete
 738         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 739         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 740
 741         seqBef := mainCtrl.get_msgcounter(t)
 742         xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
 743         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 744
 745         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 746         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 747
 748         //Wait that subs is cleaned
 749         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 750 }
 751
 752 //-----------------------------------------------------------------------------
 753 // TestSubDelReqCollision
 754 //
 755 //   stub                          stub
 756 // +-------+     +---------+    +---------+
 757 // | xapp  |     | submgr  |    | e2term  |
 758 // +-------+     +---------+    +---------+
 759 //     |              |              |
 760 //     |         [SUBS CREATE]       |
 761 //     |              |              |
 762 //     |              |              |
 763 //     | SubDelReq    |              |
 764 //     |------------->|              |
 765 //     |              |              |
 766 //     |              | SubDelReq    |
 767 //     |              |------------->|
 768 //     |              |              |
 769 //     | SubDelReq    |              |
 770 //     | (same sub)   |              |
 771 //     | (diff xid)   |              |
 772 //     |------------->|              |
 773 //     |              |              |
 774 //     |              |   SubDelResp |
 775 //     |              |<-------------|
 776 //     |              |              |
 777 //     |   SubDelResp |              |
 778 //     |<-------------|              |
 779 //
 780 //-----------------------------------------------------------------------------
 781 func TestSubDelReqCollision(t *testing.T) {
 782         xapp.Logger.Info("TestSubDelReqCollision")
 783
 784         //Subs Create
 785         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 786         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 787         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 788         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 789
 790         //Subs Delete
 791         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 792         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 793
 794         seqBef := mainCtrl.get_msgcounter(t)
 795         deltranscol := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 796         xappConn1.handle_xapp_subs_del_req(t, deltranscol, e2SubsId) //Colliding SubDelReq
 797         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 798
 799         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 800         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 801
 802         //Wait that subs is cleaned
 803         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 804 }
 805
 806 //-----------------------------------------------------------------------------
 807 // TestSubReqAndSubDelOkTwoParallel
 808 //
 809 //   stub                          stub
 810 // +-------+     +---------+    +---------+
 811 // | xapp  |     | submgr  |    | e2term  |
 812 // +-------+     +---------+    +---------+
 813 //     |              |              |
 814 //     |              |              |
 815 //     |              |              |
 816 //     | SubReq1      |              |
 817 //     |------------->|              |
 818 //     |              |              |
 819 //     |              | SubReq1      |
 820 //     |              |------------->|
 821 //     |              |              |
 822 //     | SubReq2      |              |
 823 //     |------------->|              |
 824 //     |              |              |
 825 //     |              | SubReq2      |
 826 //     |              |------------->|
 827 //     |              |              |
 828 //     |              |    SubResp1  |
 829 //     |              |<-------------|
 830 //     |              |    SubResp2  |
 831 //     |              |<-------------|
 832 //     |              |              |
 833 //     |    SubResp1  |              |
 834 //     |<-------------|              |
 835 //     |    SubResp2  |              |
 836 //     |<-------------|              |
 837 //     |              |              |
 838 //     |        [SUBS 1 DELETE]      |
 839 //     |              |              |
 840 //     |        [SUBS 2 DELETE]      |
 841 //     |              |              |
 842 //
 843 //-----------------------------------------------------------------------------
 844 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
 845         xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
 846
 847         //Req1
 848         cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
 849         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 850
 851         //Req2
 852         cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
 853         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 854
 855         //Resp1
 856         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 857         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 858
 859         //Resp2
 860         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 861         e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
 862
 863         //Del1
 864         deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
 865         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 866         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 867         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 868         //Wait that subs is cleaned
 869         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 870
 871         //Del2
 872         deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
 873         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 874         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 875         xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
 876         //Wait that subs is cleaned
 877         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 878 }
 879
 880 //-----------------------------------------------------------------------------
 881 // TestSameSubsDiffRan
 882 // Same subscription to different RANs
 883 //
 884 //   stub                          stub
 885 // +-------+     +---------+    +---------+
 886 // | xapp  |     | submgr  |    | e2term  |
 887 // +-------+     +---------+    +---------+
 888 //     |              |              |
 889 //     |              |              |
 890 //     |              |              |
 891 //     | SubReq(r1)   |              |
 892 //     |------------->|              |
 893 //     |              |              |
 894 //     |              | SubReq(r1)   |
 895 //     |              |------------->|
 896 //     |              |              |
 897 //     |              | SubResp(r1)  |
 898 //     |              |<-------------|
 899 //     |              |              |
 900 //     | SubResp(r1)  |              |
 901 //     |<-------------|              |
 902 //     |              |              |
 903 //     | SubReq(r2)   |              |
 904 //     |------------->|              |
 905 //     |              |              |
 906 //     |              | SubReq(r2)   |
 907 //     |              |------------->|
 908 //     |              |              |
 909 //     |              | SubResp(r2)  |
 910 //     |              |<-------------|
 911 //     |              |              |
 912 //     | SubResp(r2)  |              |
 913 //     |<-------------|              |
 914 //     |              |              |
 915 //     |       [SUBS r1 DELETE]      |
 916 //     |              |              |
 917 //     |       [SUBS r2 DELETE]      |
 918 //     |              |              |
 919 //
 920 //-----------------------------------------------------------------------------
 921 func TestSameSubsDiffRan(t *testing.T) {
 922         xapp.Logger.Info("TestSameSubsDiffRan")
 923
 924         //Req1
 925         cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 926         xappConn1.handle_xapp_subs_req(t, cretrans1)
 927         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 928         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 929         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 930
 931         //Req2
 932         cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
 933         xappConn1.handle_xapp_subs_req(t, cretrans2)
 934         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 935         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 936         e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
 937
 938         //Del1
 939         deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 940         xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
 941         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 942         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 943         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 944         //Wait that subs is cleaned
 945         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 946
 947         //Del2
 948         deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
 949         xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
 950         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 951         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 952         xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
 953         //Wait that subs is cleaned
 954         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 955 }
 956
 957 //-----------------------------------------------------------------------------
 958 // TestSubReqRetryInSubmgr
 959 //
 960 //   stub                          stub
 961 // +-------+     +---------+    +---------+
 962 // | xapp  |     | submgr  |    | e2term  |
 963 // +-------+     +---------+    +---------+
 964 //     |              |              |
 965 //     |  SubReq      |              |
 966 //     |------------->|              |
 967 //     |              |              |
 968 //     |              | SubReq       |
 969 //     |              |------------->|
 970 //     |              |              |
 971 //     |              |              |
 972 //     |              | SubReq       |
 973 //     |              |------------->|
 974 //     |              |              |
 975 //     |              |      SubResp |
 976 //     |              |<-------------|
 977 //     |              |              |
 978 //     |      SubResp |              |
 979 //     |<-------------|              |
 980 //     |              |              |
 981 //     |         [SUBS DELETE]       |
 982 //     |              |              |
 983 //
 984 //-----------------------------------------------------------------------------
 985
 986 func TestSubReqRetryInSubmgr(t *testing.T) {
 987
 988         xapp.Logger.Info("TestSubReqRetryInSubmgr start")
 989
 990         // Xapp: Send SubsReq
 991         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 992
 993         // E2t: Receive 1st SubsReq
 994         e2termConn.handle_e2term_subs_req(t)
 995
 996         // E2t: Receive 2nd SubsReq and send SubsResp
 997         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 998         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 999
1000         // Xapp: Receive SubsResp
1001         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1002
1003         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1004         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1005         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1006         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1007
1008         // Wait that subs is cleaned
1009         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1010 }
1011
1012 //-----------------------------------------------------------------------------
1013 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1014 //
1015 //   stub                          stub
1016 // +-------+     +---------+    +---------+
1017 // | xapp  |     | submgr  |    | e2term  |
1018 // +-------+     +---------+    +---------+
1019 //     |              |              |
1020 //     |  SubReq      |              |
1021 //     |------------->|              |
1022 //     |              |              |
1023 //     |              | SubReq       |
1024 //     |              |------------->|
1025 //     |              |              |
1026 //     |              |              |
1027 //     |              | SubReq       |
1028 //     |              |------------->|
1029 //     |              |              |
1030 //     |              | SubDelReq    |
1031 //     |              |------------->|
1032 //     |              |              |
1033 //     |              |              |
1034 //     |              | SubDelReq    |
1035 //     |              |------------->|
1036 //     |              |              |
1037 //     |              |              |
1038 //     |              |   SubDelResp |
1039 //     |              |<-------------|
1040 //     |              |              |
1041 //
1042 //-----------------------------------------------------------------------------
1043
1044 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1045
1046         xapp.Logger.Info("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1047
1048         // Xapp: Send SubsReq
1049         xappConn1.handle_xapp_subs_req(t, nil)
1050
1051         // E2t: Receive 1st SubsReq
1052         e2termConn.handle_e2term_subs_req(t)
1053
1054         // E2t: Receive 2nd SubsReq
1055         e2termConn.handle_e2term_subs_req(t)
1056
1057         // E2t: Send receive SubsDelReq and send SubsResp
1058         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1059         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1060
1061         // Wait that subs is cleaned
1062         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1063 }
1064
1065 //-----------------------------------------------------------------------------
1066 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1067 //
1068 //   stub                          stub
1069 // +-------+     +---------+    +---------+
1070 // | xapp  |     | submgr  |    | e2term  |
1071 // +-------+     +---------+    +---------+
1072 //     |              |              |
1073 //     |  SubReq      |              |
1074 //     |------------->|              |
1075 //     |              |              |
1076 //     |              | SubReq       |
1077 //     |              |------------->|
1078 //     |              |              |
1079 //     |              |              |
1080 //     |              | SubReq       |
1081 //     |              |------------->|
1082 //     |              |              |
1083 //     |              | SubDelReq    |
1084 //     |              |------------->|
1085 //     |              |              |
1086 //     |              |              |
1087 //     |              | SubDelReq    |
1088 //     |              |------------->|
1089 //     |              |              |
1090 //     |              |              |
1091 //
1092 //-----------------------------------------------------------------------------
1093
1094 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1095
1096         xapp.Logger.Info("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1097
1098         // Xapp: Send SubsReq
1099         xappConn1.handle_xapp_subs_req(t, nil)
1100
1101         // E2t: Receive 1st SubsReq
1102         e2termConn.handle_e2term_subs_req(t)
1103
1104         // E2t: Receive 2nd SubsReq
1105         e2termConn.handle_e2term_subs_req(t)
1106
1107         // E2t: Receive 1st SubsDelReq
1108         e2termConn.handle_e2term_subs_del_req(t)
1109
1110         // E2t: Receive 2nd SubsDelReq
1111         delreq, _ := e2termConn.handle_e2term_subs_del_req(t)
1112
1113         // Wait that subs is cleaned
1114         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1115 }
1116
1117 //-----------------------------------------------------------------------------
1118 // TestSubReqSubFailRespInSubmgr
1119 //
1120 //   stub                          stub
1121 // +-------+     +---------+    +---------+
1122 // | xapp  |     | submgr  |    | e2term  |
1123 // +-------+     +---------+    +---------+
1124 //     |              |              |
1125 //     |  SubReq      |              |
1126 //     |------------->|              |
1127 //     |              |              |
1128 //     |              | SubReq       |
1129 //     |              |------------->|
1130 //     |              |              |
1131 //     |              |      SubFail |
1132 //     |              |<-------------|
1133 //     |              |              |
1134 //     |      SubFail |              |
1135 //     |<-------------|              |
1136 //     |              |              |
1137 //
1138 //-----------------------------------------------------------------------------
1139
1140 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1141
1142         xapp.Logger.Info("TestSubReqSubFailRespInSubmgr start")
1143
1144         // Xapp: Send SubsReq
1145         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1146
1147         // E2t: Receive SubsReq and send SubsFail
1148         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1149         e2termConn.handle_e2term_subs_fail(t, crereq, cremsg)
1150
1151         // Xapp: Receive SubsFail
1152         e2SubsId := xappConn1.handle_xapp_subs_fail(t, cretrans)
1153
1154         // Wait that subs is cleaned
1155         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1156 }
1157
1158 //-----------------------------------------------------------------------------
1159 // TestSubDelReqRetryInSubmgr
1160 //
1161 //   stub                          stub
1162 // +-------+     +---------+    +---------+
1163 // | xapp  |     | submgr  |    | e2term  |
1164 // +-------+     +---------+    +---------+
1165 //     |              |              |
1166 //     |         [SUBS CREATE]       |
1167 //     |              |              |
1168 //     |              |              |
1169 //     | SubDelReq    |              |
1170 //     |------------->|              |
1171 //     |              |              |
1172 //     |              | SubDelReq    |
1173 //     |              |------------->|
1174 //     |              |              |
1175 //     |              | SubDelReq    |
1176 //     |              |------------->|
1177 //     |              |              |
1178 //     |              |   SubDelResp |
1179 //     |              |<-------------|
1180 //     |              |              |
1181 //     |   SubDelResp |              |
1182 //     |<-------------|              |
1183 //
1184 //-----------------------------------------------------------------------------
1185
1186 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1187
1188         xapp.Logger.Info("TestSubDelReqRetryInSubmgr start")
1189
1190         // Subs Create
1191         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1192         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1193         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1194         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1195
1196         // Subs Delete
1197         // Xapp: Send SubsDelReq
1198         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1199
1200         // E2t: Receive 1st SubsDelReq
1201         e2termConn.handle_e2term_subs_del_req(t)
1202
1203         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1204         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1205         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1206
1207         // Xapp: Receive SubsDelResp
1208         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1209
1210         // Wait that subs is cleaned
1211         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1212 }
1213
1214 //-----------------------------------------------------------------------------
1215 // TestSubDelReqTwoRetriesNoRespInSubmgr
1216 //
1217 //   stub                          stub
1218 // +-------+     +---------+    +---------+
1219 // | xapp  |     | submgr  |    | e2term  |
1220 // +-------+     +---------+    +---------+
1221 //     |              |              |
1222 //     |         [SUBS CREATE]       |
1223 //     |              |              |
1224 //     |              |              |
1225 //     | SubDelReq    |              |
1226 //     |------------->|              |
1227 //     |              |              |
1228 //     |              | SubDelReq    |
1229 //     |              |------------->|
1230 //     |              |              |
1231 //     |              | SubDelReq    |
1232 //     |              |------------->|
1233 //     |              |              |
1234 //     |              |              |
1235 //     |   SubDelResp |              |
1236 //     |<-------------|              |
1237 //
1238 //-----------------------------------------------------------------------------
1239
1240 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1241
1242         xapp.Logger.Info("TestSubDelReTwoRetriesNoRespInSubmgr start")
1243
1244         // Subs Create
1245         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1246         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1247         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1248         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1249
1250         // Subs Delete
1251         // Xapp: Send SubsDelReq
1252         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1253
1254         // E2t: Receive 1st SubsDelReq
1255         e2termConn.handle_e2term_subs_del_req(t)
1256
1257         // E2t: Receive 2nd SubsDelReq
1258         e2termConn.handle_e2term_subs_del_req(t)
1259
1260         // Xapp: Receive SubsDelResp
1261         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1262
1263         // Wait that subs is cleaned
1264         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1265 }
1266
1267 //-----------------------------------------------------------------------------
1268 // TestSubDelReqSubDelFailRespInSubmgr
1269 //
1270 //   stub                          stub
1271 // +-------+     +---------+    +---------+
1272 // | xapp  |     | submgr  |    | e2term  |
1273 // +-------+     +---------+    +---------+
1274 //     |              |              |
1275 //     |         [SUBS CREATE]       |
1276 //     |              |              |
1277 //     |              |              |
1278 //     |  SubDelReq   |              |
1279 //     |------------->|              |
1280 //     |              |              |
1281 //     |              | SubDelReq    |
1282 //     |              |------------->|
1283 //     |              |              |
1284 //     |              |   SubDelFail |
1285 //     |              |<-------------|
1286 //     |              |              |
1287 //     |   SubDelResp |              |
1288 //     |<-------------|              |
1289 //     |              |              |
1290 //
1291 //-----------------------------------------------------------------------------
1292
1293 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1294
1295         xapp.Logger.Info("TestSubReqSubDelFailRespInSubmgr start")
1296
1297         // Subs Create
1298         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1299         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1300         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1301         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1302
1303         // Xapp: Send SubsDelReq
1304         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1305
1306         // E2t: Send receive SubsDelReq and send SubsDelFail
1307         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1308         e2termConn.handle_e2term_subs_del_fail(t, delreq, delmsg)
1309
1310         // Xapp: Receive SubsDelResp
1311         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1312
1313         // Wait that subs is cleaned
1314         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1315 }