Merge "Send notification for Connected status"
[ric-plt/e2mgr.git] / E2Manager / e2pdus / configuration_update_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
19 /*
20 * This source code is part of the near-RT RIC (RAN Intelligent Controller)
21 * platform project (RICP).
22 */
23
24 package e2pdus
25
26 import (
27         "e2mgr/logger"
28         "fmt"
29         "strings"
30         "testing"
31 )
32
33 func TestPrepareEndcConfigurationUpdateFailurePDU(t *testing.T) {
34         InfoLevel:= int8(3)
35         _,err := logger.InitLogger(InfoLevel)
36         if err!=nil{
37                 t.Errorf("failed to initialize logger, error: %s", err)
38         }
39         packedPdu := "402500080000010005400142"
40         packedEndcConfigurationUpdateFailure := PackedEndcConfigurationUpdateFailure
41
42         tmp := fmt.Sprintf("%x", packedEndcConfigurationUpdateFailure)
43         if len(tmp) != len(packedPdu) {
44                 t.Errorf("want packed len:%d, got: %d\n", len(packedPdu)/2, len(packedEndcConfigurationUpdateFailure)/2)
45         }
46
47         if strings.Compare(tmp, packedPdu) != 0 {
48                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", packedPdu, tmp)
49         }
50 }
51
52 func TestPrepareEndcConfigurationUpdateFailurePDUFailure(t *testing.T) {
53         InfoLevel:= int8(3)
54         _, err := logger.InitLogger(InfoLevel)
55         if err != nil {
56                 t.Errorf("failed to initialize logger, error: %s", err)
57         }
58
59         err  = prepareEndcConfigurationUpdateFailurePDU(1, 4096)
60         if err == nil {
61                 t.Errorf("want: error, got: success.\n")
62         }
63
64         expected:= "#configuration_update.prepareEndcConfigurationUpdateFailurePDU - failed to build and pack the endc configuration update failure message #src/asn1codec_utils.c.pack_pdu_aux - Encoded output of E2AP-PDU, is too big"
65         if !strings.Contains(err.Error(), expected) {
66                 t.Errorf("want :[%s], got: [%s]\n", expected, err)
67         }
68 }
69
70 func TestPrepareX2EnbConfigurationUpdateFailurePDU(t *testing.T) {
71         InfoLevel := int8(3)
72         _,err := logger.InitLogger(InfoLevel)
73         if err!=nil{
74                 t.Errorf("failed to initialize logger, error: %s", err)
75         }
76         packedPdu := "400800080000010005400142"
77         packedEndcX2ConfigurationUpdateFailure := PackedX2EnbConfigurationUpdateFailure
78
79         tmp := fmt.Sprintf("%x", packedEndcX2ConfigurationUpdateFailure)
80         if len(tmp) != len(packedPdu) {
81                 t.Errorf("want packed len:%d, got: %d\n", len(packedPdu)/2, len(packedEndcX2ConfigurationUpdateFailure)/2)
82         }
83
84         if strings.Compare(tmp, packedPdu) != 0 {
85                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", packedPdu, tmp)
86         }
87 }
88
89 func TestPrepareX2EnbConfigurationUpdateFailurePDUFailure(t *testing.T) {
90         InfoLevel:= int8(3)
91         _, err := logger.InitLogger(InfoLevel)
92         if err != nil {
93                 t.Errorf("failed to initialize logger, error: %s", err)
94         }
95
96         err  = prepareX2EnbConfigurationUpdateFailurePDU(1, 4096)
97         if err == nil {
98                 t.Errorf("want: error, got: success.\n")
99         }
100
101         expected:= "#configuration_update.prepareX2EnbConfigurationUpdateFailurePDU - failed to build and pack the x2 configuration update failure message #src/asn1codec_utils.c.pack_pdu_aux - Encoded output of E2AP-PDU, is too big"
102         if !strings.Contains(err.Error(), expected) {
103                 t.Errorf("want :[%s], got: [%s]\n", expected, err)
104         }
105 }
106
107 func TestPrepareEndcConfigurationUpdateAckPDU(t *testing.T) {
108         InfoLevel := int8(3)
109         _,err := logger.InitLogger(InfoLevel)
110         if err!=nil{
111                 t.Errorf("failed to initialize logger, error: %s", err)
112         }
113         packedPdu := "2025000a00000100f70003000000"
114         packedEndcConfigurationUpdateAck := PackedEndcConfigurationUpdateAck
115
116         tmp := fmt.Sprintf("%x", packedEndcConfigurationUpdateAck)
117         if len(tmp) != len(packedPdu) {
118                 t.Errorf("want packed len:%d, got: %d\n", len(packedPdu)/2, len(packedEndcConfigurationUpdateAck)/2)
119         }
120
121         if strings.Compare(tmp, packedPdu) != 0 {
122                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", packedPdu, tmp)
123         }
124 }
125
126 func TestPrepareEndcConfigurationUpdateAckPDUFailure(t *testing.T) {
127         InfoLevel := int8(3)
128         _, err := logger.InitLogger(InfoLevel)
129         if err != nil {
130                 t.Errorf("failed to initialize logger, error: %s", err)
131         }
132
133         err  = prepareEndcConfigurationUpdateAckPDU(1, 4096)
134         if err == nil {
135                 t.Errorf("want: error, got: success.\n")
136         }
137
138         expected:= "#configuration_update.prepareEndcConfigurationUpdateAckPDU - failed to build and pack the endc configuration update ack message #src/asn1codec_utils.c.pack_pdu_aux - Encoded output of E2AP-PDU, is too big"
139         if !strings.Contains(err.Error(), expected) {
140                 t.Errorf("want :[%s], got: [%s]\n", expected, err)
141         }
142 }
143
144 func TestPrepareX2EnbConfigurationUpdateAckPDU(t *testing.T) {
145         InfoLevel:= int8(3)
146         _,err := logger.InitLogger(InfoLevel)
147         if err!=nil{
148                 t.Errorf("failed to initialize logger, error: %s", err)
149         }
150         packedPdu := "200800080000010011400100"
151         packedEndcX2ConfigurationUpdateAck := PackedX2EnbConfigurationUpdateAck
152
153         tmp := fmt.Sprintf("%x", packedEndcX2ConfigurationUpdateAck)
154         if len(tmp) != len(packedPdu) {
155                 t.Errorf("want packed len:%d, got: %d\n", len(packedPdu)/2, len(packedEndcX2ConfigurationUpdateAck)/2)
156         }
157
158         if strings.Compare(tmp, packedPdu) != 0 {
159                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", packedPdu, tmp)
160         }
161 }
162
163 func TestPrepareX2EnbConfigurationUpdateAckPDUFailure(t *testing.T) {
164         InfoLevel:= int8(3)
165         _, err := logger.InitLogger(InfoLevel)
166         if err != nil {
167                 t.Errorf("failed to initialize logger, error: %s", err)
168         }
169
170         err  = prepareX2EnbConfigurationUpdateAckPDU(1, 4096)
171         if err == nil {
172                 t.Errorf("want: error, got: success.\n")
173         }
174
175         expected:= "#configuration_update.prepareX2EnbConfigurationUpdateAckPDU - failed to build and pack the x2 configuration update ack message #src/asn1codec_utils.c.pack_pdu_aux - Encoded output of E2AP-PDU, is too big"
176         if !strings.Contains(err.Error(), expected) {
177                 t.Errorf("want :[%s], got: [%s]\n", expected, err)
178         }
179 }