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 // TestSubReqAndRouteNok
 591 //
 592 //   stub                          stub
 593 // +-------+     +---------+    +---------+
 594 // | xapp  |     | submgr  |    | rtmgr   |
 595 // +-------+     +---------+    +---------+
 596 //     |              |              |
 597 //     | SubReq       |              |
 598 //     |------------->|              |
 599 //     |              |              |
 600 //     |              | RouteCreate  |
 601 //     |              |------------->|
 602 //     |              |              |
 603 //     |              | RouteCreate  |
 604 //     |              |  status:400  |
 605 //     |              |<-------------|
 606 //     |              |              |
 607 //     |       [SUBS INT DELETE]     |
 608 //     |              |              |
 609 //
 610 //-----------------------------------------------------------------------------
 611
 612 func TestSubReqAndRouteNok(t *testing.T) {
 613         xapp.Logger.Info("TestSubReqAndRouteNok")
 614
 615         waiter := rtmgrHttp.AllocNextEvent(false)
 616         newSubsId := mainCtrl.get_subid(t)
 617         xappConn1.handle_xapp_subs_req(t, nil)
 618         waiter.WaitResult(t)
 619
 620         //Wait that subs is cleaned
 621         mainCtrl.wait_subs_clean(t, int(newSubsId), 10)
 622 }
 623
 624 //-----------------------------------------------------------------------------
 625 // TestSubReqAndSubDelOk
 626 //
 627 //   stub                          stub
 628 // +-------+     +---------+    +---------+
 629 // | xapp  |     | submgr  |    | e2term  |
 630 // +-------+     +---------+    +---------+
 631 //     |              |              |
 632 //     | SubReq       |              |
 633 //     |------------->|              |
 634 //     |              |              |
 635 //     |              | SubReq       |
 636 //     |              |------------->|
 637 //     |              |              |
 638 //     |              |      SubResp |
 639 //     |              |<-------------|
 640 //     |              |              |
 641 //     |      SubResp |              |
 642 //     |<-------------|              |
 643 //     |              |              |
 644 //     |              |              |
 645 //     | SubDelReq    |              |
 646 //     |------------->|              |
 647 //     |              |              |
 648 //     |              | SubDelReq    |
 649 //     |              |------------->|
 650 //     |              |              |
 651 //     |              |   SubDelResp |
 652 //     |              |<-------------|
 653 //     |              |              |
 654 //     |   SubDelResp |              |
 655 //     |<-------------|              |
 656 //
 657 //-----------------------------------------------------------------------------
 658 func TestSubReqAndSubDelOk(t *testing.T) {
 659         xapp.Logger.Info("TestSubReqAndSubDelOk")
 660
 661         waiter := rtmgrHttp.AllocNextEvent(true)
 662         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 663         waiter.WaitResult(t)
 664
 665         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 666         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 667         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 668         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 669         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 670
 671         waiter = rtmgrHttp.AllocNextEvent(true)
 672         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 673         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 674         waiter.WaitResult(t)
 675
 676         //Wait that subs is cleaned
 677         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 678 }
 679
 680 //-----------------------------------------------------------------------------
 681 // TestSubReqRetransmission
 682 //
 683 //   stub                          stub
 684 // +-------+     +---------+    +---------+
 685 // | xapp  |     | submgr  |    | e2term  |
 686 // +-------+     +---------+    +---------+
 687 //     |              |              |
 688 //     |  SubReq      |              |
 689 //     |------------->|              |
 690 //     |              |              |
 691 //     |              | SubReq       |
 692 //     |              |------------->|
 693 //     |              |              |
 694 //     |  SubReq      |              |
 695 //     | (retrans)    |              |
 696 //     |------------->|              |
 697 //     |              |              |
 698 //     |              |      SubResp |
 699 //     |              |<-------------|
 700 //     |              |              |
 701 //     |      SubResp |              |
 702 //     |<-------------|              |
 703 //     |              |              |
 704 //     |         [SUBS DELETE]       |
 705 //     |              |              |
 706 //
 707 //-----------------------------------------------------------------------------
 708 func TestSubReqRetransmission(t *testing.T) {
 709         xapp.Logger.Info("TestSubReqRetransmission")
 710
 711         //Subs Create
 712         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 713         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 714
 715         seqBef := mainCtrl.get_msgcounter(t)
 716         xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
 717         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 718
 719         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 720         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 721
 722         //Subs Delete
 723         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 724         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 725         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 726         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 727
 728         //Wait that subs is cleaned
 729         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 730 }
 731
 732 //-----------------------------------------------------------------------------
 733 // TestSubDelReqRetransmission
 734 //
 735 //   stub                          stub
 736 // +-------+     +---------+    +---------+
 737 // | xapp  |     | submgr  |    | e2term  |
 738 // +-------+     +---------+    +---------+
 739 //     |              |              |
 740 //     |         [SUBS CREATE]       |
 741 //     |              |              |
 742 //     |              |              |
 743 //     | SubDelReq    |              |
 744 //     |------------->|              |
 745 //     |              |              |
 746 //     |              | SubDelReq    |
 747 //     |              |------------->|
 748 //     |              |              |
 749 //     | SubDelReq    |              |
 750 //     | (same sub)   |              |
 751 //     | (same xid)   |              |
 752 //     |------------->|              |
 753 //     |              |              |
 754 //     |              |   SubDelResp |
 755 //     |              |<-------------|
 756 //     |              |              |
 757 //     |   SubDelResp |              |
 758 //     |<-------------|              |
 759 //
 760 //-----------------------------------------------------------------------------
 761 func TestSubDelReqRetransmission(t *testing.T) {
 762         xapp.Logger.Info("TestSubDelReqRetransmission")
 763
 764         //Subs Create
 765         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 766         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 767         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 768         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 769
 770         //Subs Delete
 771         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 772         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 773
 774         seqBef := mainCtrl.get_msgcounter(t)
 775         xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
 776         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 777
 778         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 779         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 780
 781         //Wait that subs is cleaned
 782         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 783 }
 784
 785 //-----------------------------------------------------------------------------
 786 // TestSubDelReqCollision
 787 //
 788 //   stub                          stub
 789 // +-------+     +---------+    +---------+
 790 // | xapp  |     | submgr  |    | e2term  |
 791 // +-------+     +---------+    +---------+
 792 //     |              |              |
 793 //     |         [SUBS CREATE]       |
 794 //     |              |              |
 795 //     |              |              |
 796 //     | SubDelReq    |              |
 797 //     |------------->|              |
 798 //     |              |              |
 799 //     |              | SubDelReq    |
 800 //     |              |------------->|
 801 //     |              |              |
 802 //     | SubDelReq    |              |
 803 //     | (same sub)   |              |
 804 //     | (diff xid)   |              |
 805 //     |------------->|              |
 806 //     |              |              |
 807 //     |              |   SubDelResp |
 808 //     |              |<-------------|
 809 //     |              |              |
 810 //     |   SubDelResp |              |
 811 //     |<-------------|              |
 812 //
 813 //-----------------------------------------------------------------------------
 814 func TestSubDelReqCollision(t *testing.T) {
 815         xapp.Logger.Info("TestSubDelReqCollision")
 816
 817         //Subs Create
 818         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 819         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 820         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 821         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 822
 823         //Subs Delete
 824         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 825         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 826
 827         seqBef := mainCtrl.get_msgcounter(t)
 828         deltranscol := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 829         xappConn1.handle_xapp_subs_del_req(t, deltranscol, e2SubsId) //Colliding SubDelReq
 830         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 831
 832         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 833         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 834
 835         //Wait that subs is cleaned
 836         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 837 }
 838
 839 //-----------------------------------------------------------------------------
 840 // TestSubReqAndSubDelOkTwoParallel
 841 //
 842 //   stub                          stub
 843 // +-------+     +---------+    +---------+
 844 // | xapp  |     | submgr  |    | e2term  |
 845 // +-------+     +---------+    +---------+
 846 //     |              |              |
 847 //     |              |              |
 848 //     |              |              |
 849 //     | SubReq1      |              |
 850 //     |------------->|              |
 851 //     |              |              |
 852 //     |              | SubReq1      |
 853 //     |              |------------->|
 854 //     |              |              |
 855 //     | SubReq2      |              |
 856 //     |------------->|              |
 857 //     |              |              |
 858 //     |              | SubReq2      |
 859 //     |              |------------->|
 860 //     |              |              |
 861 //     |              |    SubResp1  |
 862 //     |              |<-------------|
 863 //     |              |    SubResp2  |
 864 //     |              |<-------------|
 865 //     |              |              |
 866 //     |    SubResp1  |              |
 867 //     |<-------------|              |
 868 //     |    SubResp2  |              |
 869 //     |<-------------|              |
 870 //     |              |              |
 871 //     |        [SUBS 1 DELETE]      |
 872 //     |              |              |
 873 //     |        [SUBS 2 DELETE]      |
 874 //     |              |              |
 875 //
 876 //-----------------------------------------------------------------------------
 877 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
 878         xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
 879
 880         //Req1
 881         cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
 882         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 883
 884         //Req2
 885         cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
 886         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 887
 888         //Resp1
 889         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 890         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 891
 892         //Resp2
 893         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 894         e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
 895
 896         //Del1
 897         deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
 898         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 899         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 900         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 901         //Wait that subs is cleaned
 902         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 903
 904         //Del2
 905         deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
 906         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 907         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 908         xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
 909         //Wait that subs is cleaned
 910         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 911 }
 912
 913 //-----------------------------------------------------------------------------
 914 // TestSameSubsDiffRan
 915 // Same subscription to different RANs
 916 //
 917 //   stub                          stub
 918 // +-------+     +---------+    +---------+
 919 // | xapp  |     | submgr  |    | e2term  |
 920 // +-------+     +---------+    +---------+
 921 //     |              |              |
 922 //     |              |              |
 923 //     |              |              |
 924 //     | SubReq(r1)   |              |
 925 //     |------------->|              |
 926 //     |              |              |
 927 //     |              | SubReq(r1)   |
 928 //     |              |------------->|
 929 //     |              |              |
 930 //     |              | SubResp(r1)  |
 931 //     |              |<-------------|
 932 //     |              |              |
 933 //     | SubResp(r1)  |              |
 934 //     |<-------------|              |
 935 //     |              |              |
 936 //     | SubReq(r2)   |              |
 937 //     |------------->|              |
 938 //     |              |              |
 939 //     |              | SubReq(r2)   |
 940 //     |              |------------->|
 941 //     |              |              |
 942 //     |              | SubResp(r2)  |
 943 //     |              |<-------------|
 944 //     |              |              |
 945 //     | SubResp(r2)  |              |
 946 //     |<-------------|              |
 947 //     |              |              |
 948 //     |       [SUBS r1 DELETE]      |
 949 //     |              |              |
 950 //     |       [SUBS r2 DELETE]      |
 951 //     |              |              |
 952 //
 953 //-----------------------------------------------------------------------------
 954 func TestSameSubsDiffRan(t *testing.T) {
 955         xapp.Logger.Info("TestSameSubsDiffRan")
 956
 957         //Req1
 958         cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 959         xappConn1.handle_xapp_subs_req(t, cretrans1)
 960         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 961         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 962         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 963
 964         //Req2
 965         cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
 966         xappConn1.handle_xapp_subs_req(t, cretrans2)
 967         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 968         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 969         e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
 970
 971         //Del1
 972         deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 973         xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
 974         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 975         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 976         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 977         //Wait that subs is cleaned
 978         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 979
 980         //Del2
 981         deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
 982         xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
 983         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 984         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 985         xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
 986         //Wait that subs is cleaned
 987         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 988 }
 989
 990 //-----------------------------------------------------------------------------
 991 // TestSubReqRetryInSubmgr
 992 //
 993 //   stub                          stub
 994 // +-------+     +---------+    +---------+
 995 // | xapp  |     | submgr  |    | e2term  |
 996 // +-------+     +---------+    +---------+
 997 //     |              |              |
 998 //     |  SubReq      |              |
 999 //     |------------->|              |
1000 //     |              |              |
1001 //     |              | SubReq       |
1002 //     |              |------------->|
1003 //     |              |              |
1004 //     |              |              |
1005 //     |              | SubReq       |
1006 //     |              |------------->|
1007 //     |              |              |
1008 //     |              |      SubResp |
1009 //     |              |<-------------|
1010 //     |              |              |
1011 //     |      SubResp |              |
1012 //     |<-------------|              |
1013 //     |              |              |
1014 //     |         [SUBS DELETE]       |
1015 //     |              |              |
1016 //
1017 //-----------------------------------------------------------------------------
1018
1019 func TestSubReqRetryInSubmgr(t *testing.T) {
1020
1021         xapp.Logger.Info("TestSubReqRetryInSubmgr start")
1022
1023         // Xapp: Send SubsReq
1024         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1025
1026         // E2t: Receive 1st SubsReq
1027         e2termConn.handle_e2term_subs_req(t)
1028
1029         // E2t: Receive 2nd SubsReq and send SubsResp
1030         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1031         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1032
1033         // Xapp: Receive SubsResp
1034         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1035
1036         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1037         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1038         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1039         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1040
1041         // Wait that subs is cleaned
1042         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1043 }
1044
1045 //-----------------------------------------------------------------------------
1046 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1047 //
1048 //   stub                          stub
1049 // +-------+     +---------+    +---------+
1050 // | xapp  |     | submgr  |    | e2term  |
1051 // +-------+     +---------+    +---------+
1052 //     |              |              |
1053 //     |  SubReq      |              |
1054 //     |------------->|              |
1055 //     |              |              |
1056 //     |              | SubReq       |
1057 //     |              |------------->|
1058 //     |              |              |
1059 //     |              |              |
1060 //     |              | SubReq       |
1061 //     |              |------------->|
1062 //     |              |              |
1063 //     |              | SubDelReq    |
1064 //     |              |------------->|
1065 //     |              |              |
1066 //     |              |              |
1067 //     |              | SubDelReq    |
1068 //     |              |------------->|
1069 //     |              |              |
1070 //     |              |              |
1071 //     |              |   SubDelResp |
1072 //     |              |<-------------|
1073 //     |              |              |
1074 //
1075 //-----------------------------------------------------------------------------
1076
1077 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1078
1079         xapp.Logger.Info("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1080
1081         // Xapp: Send SubsReq
1082         xappConn1.handle_xapp_subs_req(t, nil)
1083
1084         // E2t: Receive 1st SubsReq
1085         e2termConn.handle_e2term_subs_req(t)
1086
1087         // E2t: Receive 2nd SubsReq
1088         e2termConn.handle_e2term_subs_req(t)
1089
1090         // E2t: Send receive SubsDelReq and send SubsResp
1091         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1092         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1093
1094         // Wait that subs is cleaned
1095         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1096 }
1097
1098 //-----------------------------------------------------------------------------
1099 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1100 //
1101 //   stub                          stub
1102 // +-------+     +---------+    +---------+
1103 // | xapp  |     | submgr  |    | e2term  |
1104 // +-------+     +---------+    +---------+
1105 //     |              |              |
1106 //     |  SubReq      |              |
1107 //     |------------->|              |
1108 //     |              |              |
1109 //     |              | SubReq       |
1110 //     |              |------------->|
1111 //     |              |              |
1112 //     |              |              |
1113 //     |              | SubReq       |
1114 //     |              |------------->|
1115 //     |              |              |
1116 //     |              | SubDelReq    |
1117 //     |              |------------->|
1118 //     |              |              |
1119 //     |              |              |
1120 //     |              | SubDelReq    |
1121 //     |              |------------->|
1122 //     |              |              |
1123 //     |              |              |
1124 //
1125 //-----------------------------------------------------------------------------
1126
1127 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1128
1129         xapp.Logger.Info("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1130
1131         // Xapp: Send SubsReq
1132         xappConn1.handle_xapp_subs_req(t, nil)
1133
1134         // E2t: Receive 1st SubsReq
1135         e2termConn.handle_e2term_subs_req(t)
1136
1137         // E2t: Receive 2nd SubsReq
1138         e2termConn.handle_e2term_subs_req(t)
1139
1140         // E2t: Receive 1st SubsDelReq
1141         e2termConn.handle_e2term_subs_del_req(t)
1142
1143         // E2t: Receive 2nd SubsDelReq
1144         delreq, _ := e2termConn.handle_e2term_subs_del_req(t)
1145
1146         // Wait that subs is cleaned
1147         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1148 }
1149
1150 //-----------------------------------------------------------------------------
1151 // TestSubReqSubFailRespInSubmgr
1152 //
1153 //   stub                          stub
1154 // +-------+     +---------+    +---------+
1155 // | xapp  |     | submgr  |    | e2term  |
1156 // +-------+     +---------+    +---------+
1157 //     |              |              |
1158 //     |  SubReq      |              |
1159 //     |------------->|              |
1160 //     |              |              |
1161 //     |              | SubReq       |
1162 //     |              |------------->|
1163 //     |              |              |
1164 //     |              |      SubFail |
1165 //     |              |<-------------|
1166 //     |              |              |
1167 //     |      SubFail |              |
1168 //     |<-------------|              |
1169 //     |              |              |
1170 //
1171 //-----------------------------------------------------------------------------
1172
1173 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1174
1175         xapp.Logger.Info("TestSubReqSubFailRespInSubmgr start")
1176
1177         // Xapp: Send SubsReq
1178         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1179
1180         // E2t: Receive SubsReq and send SubsFail
1181         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1182         e2termConn.handle_e2term_subs_fail(t, crereq, cremsg)
1183
1184         // Xapp: Receive SubsFail
1185         e2SubsId := xappConn1.handle_xapp_subs_fail(t, cretrans)
1186
1187         // Wait that subs is cleaned
1188         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1189 }
1190
1191 //-----------------------------------------------------------------------------
1192 // TestSubDelReqRetryInSubmgr
1193 //
1194 //   stub                          stub
1195 // +-------+     +---------+    +---------+
1196 // | xapp  |     | submgr  |    | e2term  |
1197 // +-------+     +---------+    +---------+
1198 //     |              |              |
1199 //     |         [SUBS CREATE]       |
1200 //     |              |              |
1201 //     |              |              |
1202 //     | SubDelReq    |              |
1203 //     |------------->|              |
1204 //     |              |              |
1205 //     |              | SubDelReq    |
1206 //     |              |------------->|
1207 //     |              |              |
1208 //     |              | SubDelReq    |
1209 //     |              |------------->|
1210 //     |              |              |
1211 //     |              |   SubDelResp |
1212 //     |              |<-------------|
1213 //     |              |              |
1214 //     |   SubDelResp |              |
1215 //     |<-------------|              |
1216 //
1217 //-----------------------------------------------------------------------------
1218
1219 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1220
1221         xapp.Logger.Info("TestSubDelReqRetryInSubmgr start")
1222
1223         // Subs Create
1224         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1225         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1226         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1227         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1228
1229         // Subs Delete
1230         // Xapp: Send SubsDelReq
1231         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1232
1233         // E2t: Receive 1st SubsDelReq
1234         e2termConn.handle_e2term_subs_del_req(t)
1235
1236         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1237         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1238         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1239
1240         // Xapp: Receive SubsDelResp
1241         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1242
1243         // Wait that subs is cleaned
1244         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1245 }
1246
1247 //-----------------------------------------------------------------------------
1248 // TestSubDelReqTwoRetriesNoRespInSubmgr
1249 //
1250 //   stub                          stub
1251 // +-------+     +---------+    +---------+
1252 // | xapp  |     | submgr  |    | e2term  |
1253 // +-------+     +---------+    +---------+
1254 //     |              |              |
1255 //     |         [SUBS CREATE]       |
1256 //     |              |              |
1257 //     |              |              |
1258 //     | SubDelReq    |              |
1259 //     |------------->|              |
1260 //     |              |              |
1261 //     |              | SubDelReq    |
1262 //     |              |------------->|
1263 //     |              |              |
1264 //     |              | SubDelReq    |
1265 //     |              |------------->|
1266 //     |              |              |
1267 //     |              |              |
1268 //     |   SubDelResp |              |
1269 //     |<-------------|              |
1270 //
1271 //-----------------------------------------------------------------------------
1272
1273 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1274
1275         xapp.Logger.Info("TestSubDelReTwoRetriesNoRespInSubmgr start")
1276
1277         // Subs Create
1278         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1279         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1280         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1281         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1282
1283         // Subs Delete
1284         // Xapp: Send SubsDelReq
1285         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1286
1287         // E2t: Receive 1st SubsDelReq
1288         e2termConn.handle_e2term_subs_del_req(t)
1289
1290         // E2t: Receive 2nd SubsDelReq
1291         e2termConn.handle_e2term_subs_del_req(t)
1292
1293         // Xapp: Receive SubsDelResp
1294         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1295
1296         // Wait that subs is cleaned
1297         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1298 }
1299
1300 //-----------------------------------------------------------------------------
1301 // TestSubDelReqSubDelFailRespInSubmgr
1302 //
1303 //   stub                          stub
1304 // +-------+     +---------+    +---------+
1305 // | xapp  |     | submgr  |    | e2term  |
1306 // +-------+     +---------+    +---------+
1307 //     |              |              |
1308 //     |         [SUBS CREATE]       |
1309 //     |              |              |
1310 //     |              |              |
1311 //     |  SubDelReq   |              |
1312 //     |------------->|              |
1313 //     |              |              |
1314 //     |              | SubDelReq    |
1315 //     |              |------------->|
1316 //     |              |              |
1317 //     |              |   SubDelFail |
1318 //     |              |<-------------|
1319 //     |              |              |
1320 //     |   SubDelResp |              |
1321 //     |<-------------|              |
1322 //     |              |              |
1323 //
1324 //-----------------------------------------------------------------------------
1325
1326 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1327
1328         xapp.Logger.Info("TestSubReqSubDelFailRespInSubmgr start")
1329
1330         // Subs Create
1331         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1332         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1333         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1334         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1335
1336         // Xapp: Send SubsDelReq
1337         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1338
1339         // E2t: Send receive SubsDelReq and send SubsDelFail
1340         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1341         e2termConn.handle_e2term_subs_del_fail(t, delreq, delmsg)
1342
1343         // Xapp: Receive SubsDelResp
1344         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1345
1346         // Wait that subs is cleaned
1347         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1348 }