RSM/e2pdus/resource_status_request_test.go

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