RSM/converters/resource_status_failure_unpacker_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 converters
  19
  20 import (
  21         "fmt"
  22         "rsm/e2pdus"
  23         "rsm/logger"
  24         "strings"
  25         "testing"
  26 )
  27
  28 /*
  29  * Unpack a response returned from RAN.
  30  * Verify it matches the want pdu.
  31  */
  32
  33 func TestResourceStatusFailureConverter(t *testing.T) {
  34         logger, _ := logger.InitLogger(logger.DebugLevel)
  35         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
  36         rsFailureConverter := NewResourceStatusFailureConverter(unpacker)
  37
  38         var testCases = []struct {
  39                 response  string
  40                 packedPdu string
  41         }{
  42                 {
  43                         response: "ENB1_Measurement_ID: 15, ENB2_Measurement_ID: 13, MeasurementInitiationResults:[ CellId: 02f829:0007ab50, MeasurementFailureCauses: [ MeasurementFailedReportCharacteristics: 00000007  ]  ]",
  44                         /*
  45                                         UnsuccessfulOutcome ::= {
  46                                     procedureCode: 9
  47                                     criticality: 0 (reject)
  48                                     value: ResourceStatusFailure ::= {
  49                                         protocolIEs: ProtocolIE-Container ::= {
  50                                             ResourceStatusFailure-IEs ::= {
  51                                                 id: 39
  52                                                 criticality: 0 (reject)
  53                                                 value: 15
  54                                             }
  55                                             ResourceStatusFailure-IEs ::= {
  56                                                 id: 40
  57                                                 criticality: 0 (reject)
  58                                                 value: 13
  59                                             }
  60                                             ResourceStatusFailure-IEs ::= {
  61                                                 id: 5
  62                                                 criticality: 1 (ignore)
  63                                                 value: 1 (hardware-failure)
  64                                             }
  65                                             ResourceStatusFailure-IEs ::= {
  66                                                 id: 68
  67                                                 criticality: 1 (ignore)
  68                                                 value: CompleteFailureCauseInformation-List ::= {
  69                                                     ProtocolIE-Single-Container ::= {
  70                                                         id: 69
  71                                                         criticality: 1 (ignore)
  72                                                         value: CompleteFailureCauseInformation-Item ::= {
  73                                                             cell-ID: ECGI ::= {
  74                                                                 pLMN-Identity: 02 F8 29
  75                                                                 eUTRANcellIdentifier: 00 07 AB 50 (4 bits unused)
  76                                                             }
  77                                                             measurementFailureCause-List: MeasurementFailureCause-List ::= {
  78                                                                 ProtocolIE-Single-Container ::= {
  79                                                                     id: 67
  80                                                                     criticality: 1 (ignore)
  81                                                                     value: MeasurementFailureCause-Item ::= {
  82                                                                         measurementFailedReportCharacteristics: 00 00 00 07
  83                                                                         cause: 0 (transfer-syntax-error)
  84                                                                     }
  85                                                                 }
  86                                                             }
  87                                                         }
  88                                                     }
  89                                                 }
  90                                             }
  91                                         }
  92                                     }
  93                                 }*/
  94
  95                         packedPdu: "400900320000040027000300000e0028000300000c00054001620044401800004540130002f8290007ab500000434006000000000740",
  96                 },
  97                 {
  98                         response: "ENB1_Measurement_ID: 1, ENB2_Measurement_ID: 74, MeasurementInitiationResults:[  ]",
  99                         /*
 100                                 UnsuccessfulOutcome ::= {
 101                                     procedureCode: 9
 102                                     criticality: 0 (reject)
 103                                     value: ResourceStatusFailure ::= {
 104                                         protocolIEs: ProtocolIE-Container ::= {
 105                                             ResourceStatusFailure-IEs ::= {
 106                                                 id: 39
 107                                                 criticality: 0 (reject)
 108                                                 value: 1
 109                                             }
 110                                             ResourceStatusFailure-IEs ::= {
 111                                                 id: 40
 112                                                 criticality: 0 (reject)
 113                                                 value: 74
 114                                             }
 115                                             ResourceStatusFailure-IEs ::= {
 116                                                 id: 5
 117                                                 criticality: 1 (ignore)
 118                                                 value: 21 (unspecified)
 119                                             }
 120                                         }
 121                                     }
 122                                 }
 123                         */
 124                         packedPdu: "400900170000030027000300000000280003000049000540020a80",
 125                 },
 126         }
 127
 128         for _, tc := range testCases {
 129                 t.Run(tc.packedPdu, func(t *testing.T) {
 130                         var payload []byte
 131
 132                         _, err := fmt.Sscanf(tc.packedPdu, "%x", &payload)
 133                         if err != nil {
 134                                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 135                         }
 136
 137                         response, err := rsFailureConverter.Convert(payload)
 138                         if err != nil {
 139                                 t.Errorf("want: success, got: unpack failed. Error: %v\n", err)
 140                         }
 141
 142                         got := response.String()
 143                         if len(tc.response) != len(got) {
 144                                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", tc.response, response)
 145                         }
 146                         if strings.Compare(tc.response, got) != 0 {
 147                                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", tc.response, got)
 148                         }
 149                 })
 150         }
 151 }
 152
 153 /*unpacking error*/
 154
 155 func TestResourceStatusFailureConverterError(t *testing.T) {
 156         logger, _ := logger.InitLogger(logger.InfoLevel)
 157         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 158         rsFailureConverter := NewResourceStatusFailureConverter(unpacker)
 159         wantError := "unpacking error: #src/asn1codec_utils.c.unpack_pdu_aux - Failed to decode E2AP-PDU (consumed 0), error = 0 Success"
 160         //--------------------2006002a
 161         inputPayloadAsStr := "2006002b000002001500080002f82900007a8000140017000000630002f8290007ab50102002f829000001000133"
 162         var payload []byte
 163         _, err := fmt.Sscanf(inputPayloadAsStr, "%x", &payload)
 164         if err != nil {
 165                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 166         }
 167
 168         _, err = rsFailureConverter.Convert(payload)
 169         if err != nil {
 170                 if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
 171                         t.Errorf("want failure: %s, got: %s", wantError, err)
 172                 }
 173         } else {
 174                 t.Errorf("want failure: %s, got: success", wantError)
 175
 176         }
 177 }
 178
 179 func TestResourceStatusFailureConverterPduOfSuccess(t *testing.T) {
 180         logger, _ := logger.InitLogger(logger.InfoLevel)
 181         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 182         rsFailureConverter := NewResourceStatusFailureConverter(unpacker)
 183         wantError := "unexpected PDU, 2"
 184         inputPayloadAsStr := "200900220000030027000300000e0028000300000c0041400d00004240080002f8290007ab50"
 185         var payload []byte
 186         _, err := fmt.Sscanf(inputPayloadAsStr, "%x", &payload)
 187         if err != nil {
 188                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 189         }
 190
 191         _, err = rsFailureConverter.Convert(payload)
 192         if err != nil {
 193                 if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
 194                         t.Errorf("want failure: %s, got: %s", wantError, err)
 195                 }
 196         } else {
 197                 t.Errorf("want failure: %s, got: success", wantError)
 198
 199         }
 200 }
 201
 202 func TestResourceStatusFailureConverterWrongPdu(t *testing.T) {
 203         logger, _ := logger.InitLogger(logger.InfoLevel)
 204         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 205         rsFailureConverter := NewResourceStatusFailureConverter(unpacker)
 206         wantError := "unexpected PDU - not a resource status failure"
 207         inputPayloadAsStr := "4006001a0000030005400200000016400100001140087821a00000008040"
 208         var payload []byte
 209         _, err := fmt.Sscanf(inputPayloadAsStr, "%x", &payload)
 210         if err != nil {
 211                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 212         }
 213
 214         _, err = rsFailureConverter.Convert(payload)
 215         if err != nil {
 216                 if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
 217                         t.Errorf("want failure: %s, got: %s", wantError, err)
 218                 }
 219         } else {
 220                 t.Errorf("want failure: %s, got: success", wantError)
 221
 222         }
 223 }