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