e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscription.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 e2ap_tests
  21
  22 import (
  23         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  24         "testing"
  25 )
  26
  27 //-----------------------------------------------------------------------------
  28 //
  29 //-----------------------------------------------------------------------------
  30
  31 func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionRequestWithData(t *testing.T, areqenc *e2ap.E2APSubscriptionRequest) {
  32
  33         e2SubsReq := testCtxt.packerif.NewPackerSubscriptionRequest()
  34
  35         testCtxt.testPrint("########## ##########")
  36         testCtxt.testPrint("init")
  37         seterr := e2SubsReq.Set(areqenc)
  38         if seterr != nil {
  39                 testCtxt.testError(t, "set err: %s", seterr.Error())
  40                 return
  41         }
  42         testCtxt.testPrint("print:\n%s", e2SubsReq.String())
  43         testCtxt.testPrint("pack")
  44         err, packedMsg := e2SubsReq.Pack(nil)
  45         if err != nil {
  46                 testCtxt.testError(t, "Pack failed: %s", err.Error())
  47                 return
  48         }
  49         testCtxt.testPrint("unpack")
  50         err = e2SubsReq.UnPack(packedMsg)
  51         if err != nil {
  52                 testCtxt.testError(t, "UnPack failed: %s", err.Error())
  53                 return
  54         }
  55         testCtxt.testPrint("print:\n%s", e2SubsReq.String())
  56         geterr, areqdec := e2SubsReq.Get()
  57         if geterr != nil {
  58                 testCtxt.testError(t, "get nil: %s", geterr.Error())
  59                 return
  60         }
  61         testCtxt.testValueEquality(t, "msg", areqenc, areqdec)
  62         testCtxt.testValueEquality(t, "EventTriggerDefinition", &areqenc.EventTriggerDefinition, &areqdec.EventTriggerDefinition)
  63 }
  64
  65 func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionRequest(t *testing.T) {
  66
  67         areqenc := e2ap.E2APSubscriptionRequest{}
  68         areqenc.RequestId.Id = 1
  69         areqenc.RequestId.Seq = 22
  70         areqenc.FunctionId = 33
  71         //Bits 20, 28(works), 18, 21 (asn1 problems)
  72         areqenc.EventTriggerDefinition.InterfaceDirection = e2ap.E2AP_InterfaceDirectionIncoming
  73         areqenc.EventTriggerDefinition.ProcedureCode = 35
  74         areqenc.EventTriggerDefinition.TypeOfMessage = e2ap.E2AP_InitiatingMessage
  75         for index := 0; index < 16; index++ {
  76                 item := e2ap.ActionToBeSetupItem{}
  77                 item.ActionId = uint64(index)
  78                 item.ActionType = e2ap.E2AP_ActionTypeInsert
  79                 // NOT SUPPORTED CURRENTLY
  80                 //item.ActionDefinition.Present = true
  81                 //item.ActionDefinition.StyleId = 255
  82                 //item.ActionDefinition.ParamId = 222
  83                 item.SubsequentAction.Present = true
  84                 item.SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue
  85                 item.SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW100ms
  86                 areqenc.ActionSetups = append(areqenc.ActionSetups, item)
  87         }
  88
  89         areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true
  90         areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150")
  91         areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDHomeBits28
  92         areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 202251
  93         testCtxt.SetDesc("SubsReq-28bit")
  94         testCtxt.E2ApTestMsgSubscriptionRequestWithData(t, &areqenc)
  95
  96         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true
  97         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150")
  98         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDShortMacroits18
  99         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 55
 100         //testCtxt.SetDesc("SubsReq-18bit")
 101         //testCtxt.E2ApTestMsgSubscriptionRequestWithData(t,&areqenc)
 102
 103         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true
 104         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150")
 105         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDMacroPBits20
 106         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 55
 107         //testCtxt.SetDesc("SubsReq-20bit")
 108         //testCtxt.E2ApTestMsgSubscriptionRequestWithData(t,&areqenc)
 109
 110         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true
 111         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150")
 112         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDlongMacroBits21
 113         //areqenc.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 55
 114         //testCtxt.SetDesc("SubsReq-21bit")
 115         //testCtxt.E2ApTestMsgSubscriptionRequestWithData(t,&areqenc)
 116
 117 }
 118
 119 func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionResponse(t *testing.T) {
 120
 121         testCtxt.SetDesc("SubsResp")
 122
 123         e2SubsResp := testCtxt.packerif.NewPackerSubscriptionResponse()
 124
 125         testCtxt.testPrint("########## ##########")
 126         testCtxt.testPrint("init")
 127
 128         arespenc := e2ap.E2APSubscriptionResponse{}
 129         arespenc.RequestId.Id = 1
 130         arespenc.RequestId.Seq = 22
 131         arespenc.FunctionId = 33
 132         for index := uint64(0); index < 16; index++ {
 133                 item := e2ap.ActionAdmittedItem{}
 134                 item.ActionId = index
 135                 arespenc.ActionAdmittedList.Items = append(arespenc.ActionAdmittedList.Items, item)
 136         }
 137         for index := uint64(0); index < 16; index++ {
 138                 item := e2ap.ActionNotAdmittedItem{}
 139                 item.ActionId = index
 140                 item.Cause.Content = 1
 141                 item.Cause.CauseVal = 1
 142                 arespenc.ActionNotAdmittedList.Items = append(arespenc.ActionNotAdmittedList.Items, item)
 143         }
 144
 145         seterr := e2SubsResp.Set(&arespenc)
 146         if seterr != nil {
 147                 testCtxt.testError(t, "set err: %s", seterr.Error())
 148                 return
 149         }
 150         testCtxt.testPrint("print:\n%s", e2SubsResp.String())
 151         testCtxt.testPrint("pack")
 152         err, packedMsg := e2SubsResp.Pack(nil)
 153         if err != nil {
 154                 testCtxt.testError(t, "Pack failed: %s", err.Error())
 155                 return
 156         }
 157         testCtxt.testPrint("unpack")
 158         err = e2SubsResp.UnPack(packedMsg)
 159         if err != nil {
 160                 testCtxt.testError(t, "UnPack failed: %s", err.Error())
 161                 return
 162         }
 163         testCtxt.testPrint("print:\n%s", e2SubsResp.String())
 164         geterr, arespdec := e2SubsResp.Get()
 165         if geterr != nil {
 166                 testCtxt.testError(t, "get nil: %s", geterr.Error())
 167                 return
 168         }
 169         testCtxt.testValueEquality(t, "msg", &arespenc, arespdec)
 170 }
 171
 172 func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionFailure(t *testing.T) {
 173
 174         testCtxt.SetDesc("SubsFail")
 175
 176         e2SubsFail := testCtxt.packerif.NewPackerSubscriptionFailure()
 177
 178         testCtxt.testPrint("########## ##########")
 179         testCtxt.testPrint("init")
 180
 181         afailenc := e2ap.E2APSubscriptionFailure{}
 182         afailenc.RequestId.Id = 1
 183         afailenc.RequestId.Seq = 22
 184         afailenc.FunctionId = 33
 185         for index := uint64(0); index < 16; index++ {
 186                 item := e2ap.ActionNotAdmittedItem{}
 187                 item.ActionId = index
 188                 item.Cause.Content = 1
 189                 item.Cause.CauseVal = 1
 190                 afailenc.ActionNotAdmittedList.Items = append(afailenc.ActionNotAdmittedList.Items, item)
 191         }
 192         // NOT SUPPORTED CURRENTLY
 193         afailenc.CriticalityDiagnostics.Present = false
 194         //      afailenc.CriticalityDiagnostics.ProcCodePresent = true
 195         //      afailenc.CriticalityDiagnostics.ProcCode = 1
 196         //      afailenc.CriticalityDiagnostics.TrigMsgPresent = true
 197         //      afailenc.CriticalityDiagnostics.TrigMsg = 2
 198         //      afailenc.CriticalityDiagnostics.ProcCritPresent = true
 199         //      afailenc.CriticalityDiagnostics.ProcCrit = e2ap.E2AP_CriticalityReject
 200         //      for index := uint32(0); index < 256; index++ {
 201         //              ieitem := e2ap.CriticalityDiagnosticsIEListItem{}
 202         //              ieitem.IeCriticality = e2ap.E2AP_CriticalityReject
 203         //              ieitem.IeID = index
 204         //              ieitem.TypeOfError = 1
 205         //              afailenc.CriticalityDiagnostics.CriticalityDiagnosticsIEList.Items = append(afailenc.CriticalityDiagnostics.CriticalityDiagnosticsIEList.Items, ieitem)
 206         //      }
 207
 208         seterr := e2SubsFail.Set(&afailenc)
 209         if seterr != nil {
 210                 testCtxt.testError(t, "set err: %s", seterr.Error())
 211                 return
 212         }
 213         testCtxt.testPrint("print:\n%s", e2SubsFail.String())
 214         testCtxt.testPrint("pack")
 215         err, packedMsg := e2SubsFail.Pack(nil)
 216         if err != nil {
 217                 testCtxt.testError(t, "Pack failed: %s", err.Error())
 218                 return
 219         }
 220         testCtxt.testPrint("unpack")
 221         err = e2SubsFail.UnPack(packedMsg)
 222         if err != nil {
 223                 testCtxt.testError(t, "UnPack failed: %s", err.Error())
 224                 return
 225         }
 226         testCtxt.testPrint("print:\n%s", e2SubsFail.String())
 227         geterr, afaildec := e2SubsFail.Get()
 228         if geterr != nil {
 229                 testCtxt.testError(t, "get nil: %s", geterr.Error())
 230                 return
 231         }
 232         testCtxt.testValueEquality(t, "msg", &afailenc, afaildec)
 233 }
 234
 235 func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionRequestBuffers(t *testing.T) {
 236
 237         testfunc := func(buffer string) {
 238                 packedData := testCtxt.toPackedData(t, buffer)
 239                 if packedData == nil {
 240                         return
 241                 }
 242                 e2SubResp := testCtxt.packerif.NewPackerSubscriptionRequest()
 243                 err := e2SubResp.UnPack(packedData)
 244                 if err != nil {
 245                         testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer)
 246                         return
 247                 }
 248                 err, _ = e2SubResp.Get()
 249                 if err != nil {
 250                         testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer)
 251                         return
 252                 }
 253                 testCtxt.testPrint("OK [%s]", buffer)
 254         }
 255
 256         testCtxt.SetDesc("SubReqBuffer")
 257         testfunc("00c9402c000003ea7e00050000010000ea6300020001ea810016000b00130051407b000000054000ea6b000420000000")
 258 }
 259
 260 func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionResponseBuffers(t *testing.T) {
 261
 262         testfunc := func(buffer string) {
 263                 packedData := testCtxt.toPackedData(t, buffer)
 264                 if packedData == nil {
 265                         return
 266                 }
 267                 e2SubResp := testCtxt.packerif.NewPackerSubscriptionResponse()
 268                 err := e2SubResp.UnPack(packedData)
 269                 if err != nil {
 270                         testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer)
 271                         return
 272                 }
 273                 err, _ = e2SubResp.Get()
 274                 if err != nil {
 275                         testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer)
 276                         return
 277                 }
 278                 testCtxt.testPrint("OK [%s]", buffer)
 279         }
 280
 281         testCtxt.SetDesc("SubRespBuffer")
 282         testfunc("20c9402a000004ea7e00050000018009ea6300020001ea6c000700ea6d00020000ea6e000908ea6f000400000040")
 283         testfunc("20c9401d000003ea7e0005004eec0004ea6300020001ea6c000700ea6d40020000")
 284
 285 }
 286
 287 func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionFailureBuffers(t *testing.T) {
 288
 289         testfunc := func(buffer string) {
 290                 packedData := testCtxt.toPackedData(t, buffer)
 291                 if packedData == nil {
 292                         return
 293                 }
 294                 e2SubResp := testCtxt.packerif.NewPackerSubscriptionFailure()
 295                 err := e2SubResp.UnPack(packedData)
 296                 if err != nil {
 297                         testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer)
 298                         return
 299                 }
 300                 err, _ = e2SubResp.Get()
 301                 if err != nil {
 302                         testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer)
 303                         return
 304                 }
 305                 testCtxt.testPrint("OK [%s]", buffer)
 306         }
 307
 308         testCtxt.SetDesc("SubFailBuffer")
 309         testfunc("40c94017000003ea7e000500000106f3ea6300020001ea6e000100")
 310 }