e2ap/pkg/conv/plmn_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 conv
  21
  22 import (
  23         "bytes"
  24         "testing"
  25 )
  26
  27 //-----------------------------------------------------------------------------
  28 //
  29 //-----------------------------------------------------------------------------
  30 func TestPlmnId(t *testing.T) {
  31         var ident PlmnIdentity
  32         ident.Set("12345")
  33         if ident.Mcc != "123" {
  34                 t.Errorf("TestPlmnId: mcc expect 123 was %s", ident.Mcc)
  35         }
  36         if ident.Mnc != "45" {
  37                 t.Errorf("TestPlmnId: mnc expect 45 was %s", ident.Mnc)
  38         }
  39
  40         ident.Set("123456")
  41         if ident.Mcc != "123" {
  42                 t.Errorf("TestPlmnId: mcc expect 123 was %s", ident.Mcc)
  43         }
  44         if ident.Mnc != "456" {
  45                 t.Errorf("TestPlmnId: mnc expect 456 was %s", ident.Mnc)
  46         }
  47
  48 }
  49
  50 //-----------------------------------------------------------------------------
  51 //
  52 //-----------------------------------------------------------------------------
  53 func TestPlmnIdBcd1(t *testing.T) {
  54
  55         var encident PlmnIdentityBcd
  56         encident.Mcc = "233"
  57         encident.Mnc = "50"
  58         encbuf := new(bytes.Buffer)
  59         retlen, err := encident.EncodeTo(encbuf)
  60
  61         if err != nil {
  62                 t.Errorf("TestPlmnIdBcd1: EncodeTo err %s", err.Error())
  63         }
  64         if retlen != 3 {
  65                 t.Errorf("TestPlmnIdBcd1: EncodeTo expected len 3 got %d", retlen)
  66         }
  67
  68         encdata := encbuf.Bytes()
  69
  70         if encdata[0] != 0x23 {
  71                 t.Errorf("TestPlmnIdBcd1: encident.val[0] expected 0x23 got 0x%x", encdata[0])
  72         }
  73
  74         if encdata[1] != 0x3f {
  75                 t.Errorf("TestPlmnIdBcd1: encident.val[1] expected 0x3f got 0x%x", encdata[1])
  76         }
  77
  78         if encdata[2] != 0x50 {
  79                 t.Errorf("TestPlmnIdBcd1: encident.val[2] expected 0x50 got 0x%x", encdata[2])
  80         }
  81
  82         var decident PlmnIdentityBcd
  83         decbuf := []byte{0x23, 0x3f, 0x50}
  84
  85         reader := bytes.NewReader(decbuf)
  86         retlen, err = decident.DecodeFrom(reader)
  87
  88         if err != nil {
  89                 t.Errorf("TestPlmnIdBcd1: DecodeFrom err %s", err.Error())
  90         }
  91         if retlen != 3 {
  92                 t.Errorf("TestPlmnIdBcd1: DecodeFrom expected len 3 got %d", retlen)
  93         }
  94
  95         if decident.Mcc != "233" {
  96                 t.Errorf("TestPlmnIdBcd1: mcc expected 233 got %s", decident.Mcc)
  97         }
  98         if decident.Mnc != "50" {
  99                 t.Errorf("TestPlmnIdBcd1: mnc expected 50 got %s", decident.Mnc)
 100         }
 101 }
 102
 103 func TestPlmnIdBcd2(t *testing.T) {
 104
 105         var encident PlmnIdentityBcd
 106
 107         encident.Mcc = "233"
 108         encident.Mnc = "550"
 109         encbuf := new(bytes.Buffer)
 110         retlen, err := encident.EncodeTo(encbuf)
 111
 112         if err != nil {
 113                 t.Errorf("TestPlmnIdBcd2: EncodeTo err %s", err.Error())
 114         }
 115         if retlen != 3 {
 116                 t.Errorf("TestPlmnIdBcd2: EncodeTo expected len 3 got %d", retlen)
 117         }
 118
 119         encdata := encbuf.Bytes()
 120
 121         if encdata[0] != 0x23 {
 122                 t.Errorf("TestPlmnIdBcd2: encident.val[0] expected 0x23 got 0x%x", encdata[0])
 123         }
 124
 125         if encdata[1] != 0x35 {
 126                 t.Errorf("TestPlmnIdBcd1: encident.val[1] expected 0x35 got 0x%x", encdata[1])
 127         }
 128
 129         if encdata[2] != 0x50 {
 130                 t.Errorf("TestPlmnIdBcd2: encident.val[2] expected 0x50 got 0x%x", encdata[2])
 131         }
 132
 133         var decident PlmnIdentityBcd
 134         decbuf := []byte{0x23, 0x35, 0x50}
 135
 136         reader := bytes.NewReader(decbuf)
 137         retlen, err = decident.DecodeFrom(reader)
 138
 139         if err != nil {
 140                 t.Errorf("TestPlmnIdBcd2: DecodeFrom err %s", err.Error())
 141         }
 142         if retlen != 3 {
 143                 t.Errorf("TestPlmnIdBcd2: DecodeFrom expected len 3 got %d", retlen)
 144         }
 145
 146         if decident.Mcc != "233" {
 147                 t.Errorf("TestPlmnIdBcd2: mcc expected 233 got %s", decident.Mcc)
 148         }
 149         if decident.Mnc != "550" {
 150                 t.Errorf("TestPlmnIdBcd2: mnc expected 550 got %s", decident.Mnc)
 151         }
 152 }
 153
 154 //-----------------------------------------------------------------------------
 155 //
 156 //-----------------------------------------------------------------------------
 157 func TestPlmnIdTbcd1(t *testing.T) {
 158
 159         var encident PlmnIdentityTbcd
 160         encident.Mcc = "233"
 161         encident.Mnc = "50"
 162         encbuf := new(bytes.Buffer)
 163         retlen, err := encident.EncodeTo(encbuf)
 164
 165         if err != nil {
 166                 t.Errorf("TestPlmnIdTbcd1: EncodeTo err %s", err.Error())
 167         }
 168         if retlen != 3 {
 169                 t.Errorf("TestPlmnIdTbcd1: EncodeTo expected len 3 got %d", retlen)
 170         }
 171
 172         encdata := encbuf.Bytes()
 173
 174         if encdata[0] != 0x32 {
 175                 t.Errorf("TestPlmnIdTbcd1: encident.val[0] expected 0x32 got 0x%x", encdata[0])
 176         }
 177
 178         if encdata[1] != 0xf3 {
 179                 t.Errorf("TestPlmnIdTbcd1: encident.val[1] expected 0xf3 got 0x%x", encdata[1])
 180         }
 181
 182         if encdata[2] != 0x05 {
 183                 t.Errorf("TestPlmnIdTbcd1: encident.val[2] expected 0x05 got 0x%x", encdata[2])
 184         }
 185
 186         var decident PlmnIdentityTbcd
 187         decbuf := []byte{0x32, 0xf3, 0x05}
 188
 189         reader := bytes.NewReader(decbuf)
 190         retlen, err = decident.DecodeFrom(reader)
 191
 192         if err != nil {
 193                 t.Errorf("TestPlmnIdTbcd1: DecodeFrom err %s", err.Error())
 194         }
 195         if retlen != 3 {
 196                 t.Errorf("TestPlmnIdTbcd1: DecodeFrom expected len 3 got %d", retlen)
 197         }
 198
 199         if decident.Mcc != "233" {
 200                 t.Errorf("TestPlmnIdTbcd1: mcc expected 233 got %s", decident.Mcc)
 201         }
 202         if decident.Mnc != "50" {
 203                 t.Errorf("TestPlmnIdTbcd1: mnc expected 50 got %s", decident.Mnc)
 204         }
 205 }
 206
 207 func TestPlmnIdTbcd2(t *testing.T) {
 208
 209         var encident PlmnIdentityTbcd
 210
 211         encident.Mcc = "233"
 212         encident.Mnc = "550"
 213         encbuf := new(bytes.Buffer)
 214         retlen, err := encident.EncodeTo(encbuf)
 215
 216         if err != nil {
 217                 t.Errorf("TestPlmnIdTbcd2: EncodeTo err %s", err.Error())
 218         }
 219         if retlen != 3 {
 220                 t.Errorf("TestPlmnIdTbcd2: EncodeTo expected len 3 got %d", retlen)
 221         }
 222
 223         encdata := encbuf.Bytes()
 224
 225         if encdata[0] != 0x32 {
 226                 t.Errorf("TestPlmnIdTbcd2: encident.val[0] expected 0x32 got 0x%x", encdata[0])
 227         }
 228
 229         if encdata[1] != 0x03 {
 230                 t.Errorf("TestPlmnIdTbcd1: encident.val[1] expected 0x03 got 0x%x", encdata[1])
 231         }
 232
 233         if encdata[2] != 0x55 {
 234                 t.Errorf("TestPlmnIdTbcd2: encident.val[2] expected 0x55 got 0x%x", encdata[2])
 235         }
 236
 237         var decident PlmnIdentityTbcd
 238         decbuf := []byte{0x32, 0x03, 0x55}
 239
 240         reader := bytes.NewReader(decbuf)
 241         retlen, err = decident.DecodeFrom(reader)
 242
 243         if err != nil {
 244                 t.Errorf("TestPlmnIdTbcd2: DecodeFrom err %s", err.Error())
 245         }
 246         if retlen != 3 {
 247                 t.Errorf("TestPlmnIdTbcd2: DecodeFrom expected len 3 got %d", retlen)
 248         }
 249
 250         if decident.Mcc != "233" {
 251                 t.Errorf("TestPlmnIdTbcd2: mcc expected 233 got %s", decident.Mcc)
 252         }
 253         if decident.Mnc != "550" {
 254                 t.Errorf("TestPlmnIdTbcd2: mnc expected 550 got %s", decident.Mnc)
 255         }
 256 }