Copying only the needed libraries to final image
[ric-plt/submgr.git] / 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 }