RSM/e2pdus/resource_status_request_test.go

   1 /*
   2  *   Copyright (c) 2019 AT&T Intellectual Property.
   3  *
   4  *   Licensed under the Apache License, Version 2.0 (the "License");
   5  *   you may not use this file except in compliance with the License.
   6  *   You may obtain a copy of the License at
   7  *
   8  *       http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *   Unless required by applicable law or agreed to in writing, software
  11  *   distributed under the License is distributed on an "AS IS" BASIS,
  12  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *   See the License for the specific language governing permissions and
  14  *   limitations under the License.
  15  */
  16
  17 /*
  18  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19  * platform project (RICP).
  20  */
  21
  22 package e2pdus
  23
  24 import (
  25         "fmt"
  26         "rsm/enums"
  27         "strings"
  28         "testing"
  29 )
  30
  31 /*
  32  * Create and pack an x2ap setup request.
  33  * Verify the packed representation matches the want value.
  34  */
  35 func TestBuildPackedResourceStatusRequest(t *testing.T) {
  36         var testCases = []struct {
  37                 request   ResourceStatusRequestData
  38                 packedPdu string
  39         }{
  40                 {
  41                         request: ResourceStatusRequestData{
  42                                 CellID:                                           "0a0b0c:abcd8000",
  43                                 MeasurementID:                15,
  44                                 MeasurementID2:               0,
  45                                 PartialSuccessAllowed:        true,
  46                                 PrbPeriodic:                  true,
  47                                 TnlLoadIndPeriodic:           true,
  48                                 HwLoadIndPeriodic:            true,
  49                                 AbsStatusPeriodic:            true,
  50                                 RsrpMeasurementPeriodic:      true,
  51                                 CsiPeriodic:                  true,
  52                                 PeriodicityMS:                enums.ReportingPeriodicity_one_thousand_ms,
  53                                 PeriodicityRsrpMeasurementMS: enums.ReportingPeriodicityRSRPMR_one_hundred_20_ms,
  54                                 PeriodicityCsiMS:             enums.ReportingPeriodicityCSIR_ms5,
  55                         },
  56                         packedPdu: "0009003c0000080027000300000e001c00010000260004fe000000001d400d00001f4008000a0b0cabcd8000001e4001000040400100006d4001000091400100",
  57                 },
  58                 {
  59                         request: ResourceStatusRequestData{
  60                                 CellID:                                           "0a0b0c:abcd8000",
  61                                 MeasurementID:                15,
  62                                 MeasurementID2:               0,
  63                                 PartialSuccessAllowed:        true,
  64                                 PrbPeriodic:                  true,
  65                                 TnlLoadIndPeriodic:           true,
  66                                 HwLoadIndPeriodic:            true,
  67                                 AbsStatusPeriodic:            true,
  68                                 RsrpMeasurementPeriodic:      true,
  69                                 CsiPeriodic:                  true,
  70                                 PeriodicityMS:                0,
  71                                 PeriodicityRsrpMeasurementMS: 0,
  72                                 PeriodicityCsiMS:             0,
  73                         },
  74                         packedPdu: "0009002d0000050027000300000e001c00010000260004fe000000001d400d00001f4008000a0b0cabcd80000040400100",
  75                 },
  76                 {
  77                         request: ResourceStatusRequestData{
  78                                 CellID:                                           "0a0b0c:abcd8000",
  79                                 MeasurementID:                15,
  80                                 MeasurementID2:               0,
  81                                 PartialSuccessAllowed:        true,
  82                                 PrbPeriodic:                  false,
  83                                 TnlLoadIndPeriodic:           false,
  84                                 HwLoadIndPeriodic:            false,
  85                                 AbsStatusPeriodic:            true,
  86                                 RsrpMeasurementPeriodic:      true,
  87                                 CsiPeriodic:                  true,
  88                                 PeriodicityMS:                0,
  89                                 PeriodicityRsrpMeasurementMS: 0,
  90                                 PeriodicityCsiMS:             0,
  91                         },
  92                         packedPdu: "0009002d0000050027000300000e001c000100002600040e000000001d400d00001f4008000a0b0cabcd80000040400100",
  93                 },
  94                 {
  95                         request: ResourceStatusRequestData{
  96                                 CellID:                                           "0a0b0c:abcd8000",
  97                                 MeasurementID:                15,
  98                                 MeasurementID2:               0,
  99                                 PartialSuccessAllowed:        false,
 100                                 PrbPeriodic:                  false,
 101                                 TnlLoadIndPeriodic:           false,
 102                                 HwLoadIndPeriodic:            false,
 103                                 AbsStatusPeriodic:            true,
 104                                 RsrpMeasurementPeriodic:      true,
 105                                 CsiPeriodic:                  true,
 106                                 PeriodicityMS:                enums.ReportingPeriodicity_ten_thousand_ms,
 107                                 PeriodicityRsrpMeasurementMS: enums.ReportingPeriodicityRSRPMR_six_hundred_40_ms,
 108                                 PeriodicityCsiMS:             enums.ReportingPeriodicityCSIR_ms80,
 109                         },
 110                         packedPdu: "000900370000070027000300000e001c000100002600040e000000001d400d00001f4008000a0b0cabcd8000001e400160006d4001600091400140",
 111                 },
 112         }
 113
 114         for _, tc := range testCases {
 115                 t.Run(tc.packedPdu, func(t *testing.T) {
 116
 117                         payload, asString, err := BuildPackedResourceStatusRequest(enums.Registration_Request_start, &tc.request, MaxAsn1PackedBufferSize /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, true /*withDebug*/)
 118                         if err != nil {
 119                                 t.Errorf("want: success, got: pack failed. Error: %v\n", err)
 120                         } else {
 121                                 t.Logf("packed resource status request (size=%d): %x\n\n%s", len(payload), payload,asString)
 122                                 tmp := fmt.Sprintf("%x", payload)
 123                                 if len(tmp) != len(tc.packedPdu) {
 124                                         t.Errorf("want packed len:%d, got: %d\n", len(tc.packedPdu)/2, len(payload)/2)
 125                                 }
 126
 127                                 if strings.Compare(tmp, tc.packedPdu) != 0 {
 128                                         t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", tc.packedPdu, tmp)
 129                                 }
 130                         }
 131                 })
 132         }
 133 }
 134
 135 /*Packing error*/
 136
 137 func TestBuildPackedResourceStatusRequestError(t *testing.T) {
 138         request := ResourceStatusRequestData{
 139                 CellID:                                           "0a0b0c:abcd8000",
 140                 MeasurementID:                15,
 141                 MeasurementID2:               0,
 142                 PrbPeriodic:                  true,
 143                 TnlLoadIndPeriodic:           true,
 144                 HwLoadIndPeriodic:            true,
 145                 AbsStatusPeriodic:            true,
 146                 RsrpMeasurementPeriodic:      true,
 147                 CsiPeriodic:                  true,
 148                 PeriodicityMS:                enums.ReportingPeriodicity_one_thousand_ms,
 149                 PeriodicityRsrpMeasurementMS: enums.ReportingPeriodicityRSRPMR_one_hundred_20_ms,
 150                 PeriodicityCsiMS:             enums.ReportingPeriodicityCSIR_ms5,
 151         }
 152         expected:= "packing error: #src/asn1codec_utils.c.pack_pdu_aux - Encoded output of E2AP-PDU, is too big"
 153         _, _, err := BuildPackedResourceStatusRequest(enums.Registration_Request_start, &request, 40 /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, true /*withDebug*/)
 154         if err != nil {
 155                 if !strings.Contains(err.Error(), expected) {
 156                         t.Errorf("want failure:[%s], got: [%s]\n", expected, err)
 157                 }
 158         } else {
 159                 t.Errorf("want failure: ...%s..., got: success", expected)
 160
 161         }
 162 }
 163
 164 func TestBuildPackedResourceStatusInvalidCellID(t *testing.T) {
 165         request := ResourceStatusRequestData{
 166                 CellID:                                           "0a0b0cabcd8000",
 167                 MeasurementID:                15,
 168                 MeasurementID2:               0,
 169                 PrbPeriodic:                  true,
 170                 TnlLoadIndPeriodic:           true,
 171                 HwLoadIndPeriodic:            true,
 172                 AbsStatusPeriodic:            true,
 173                 RsrpMeasurementPeriodic:      true,
 174                 CsiPeriodic:                  true,
 175                 PeriodicityMS:                enums.ReportingPeriodicity_one_thousand_ms,
 176                 PeriodicityRsrpMeasurementMS: enums.ReportingPeriodicityRSRPMR_one_hundred_20_ms,
 177                 PeriodicityCsiMS:             enums.ReportingPeriodicityCSIR_ms5,
 178         }
 179         expected:= "BuildPackedResourceStatusRequest() - unexpected CellID value [0a0b0cabcd8000] (want: \"<PLMNIdentifier>:<eUTRANCellIdentifier>\"), err: unexpected EOF"
 180         _, _, err := BuildPackedResourceStatusRequest(enums.Registration_Request_start, &request, MaxAsn1PackedBufferSize /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, true /*withDebug*/)
 181         if err != nil {
 182                 if !strings.Contains(err.Error(), expected) {
 183                         t.Errorf("want failure:[%s], got: [%s]\n", expected, err)
 184                 }
 185         } else {
 186                 t.Errorf("want failure: ...%s..., got: success", expected)
 187
 188         }
 189 }
 190
 191 func TestBuildPackedResourceStatusInvalidPeriodicity(t *testing.T) {
 192         request := ResourceStatusRequestData{
 193                 CellID:                                           "0a0b0c:abcd8000",
 194                 MeasurementID:                15,
 195                 MeasurementID2:               0,
 196                 PrbPeriodic:                  true,
 197                 TnlLoadIndPeriodic:           true,
 198                 HwLoadIndPeriodic:            true,
 199                 AbsStatusPeriodic:            true,
 200                 RsrpMeasurementPeriodic:      true,
 201                 CsiPeriodic:                  true,
 202                 PeriodicityMS:                22,
 203                 PeriodicityRsrpMeasurementMS: enums.ReportingPeriodicityRSRPMR_one_hundred_20_ms,
 204                 PeriodicityCsiMS:             enums.ReportingPeriodicityCSIR_ms5,
 205         }
 206         expected:= "BuildPackedResourceStatusRequest - packing error: #src/asn1codec_utils.c.pack_pdu_aux - Failed to encode E2AP-PDU, error = 9 Bad file descriptor"
 207         _, _, err := BuildPackedResourceStatusRequest(enums.Registration_Request_start, &request, MaxAsn1PackedBufferSize /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, true /*withDebug*/)
 208         if err != nil {
 209                 if !strings.Contains(err.Error(), expected) {
 210                         t.Errorf("want failure:[%s], got: [%s]\n", expected, err)
 211                 }
 212         } else {
 213                 t.Errorf("want failure: ...%s..., got: success", expected)
 214
 215         }
 216 }