2 ==================================================================================
4 Copyright (c) 2018-2019 AT&T Intellectual Property.
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
10 http://www.apache.org/licenses/LICENSE-2.0
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 ==================================================================================
20 #define CATCH_CONFIG_MAIN
21 #include <catch2/catch.hpp>
28 TEST_CASE("E2SM Event Trigger Test Cases", "Encoding/decoding"){
31 unsigned char buf[128];
32 size_t buf_size = 128;
35 asn_dec_rval_t retval;
37 e2sm_event_trigger_helper trigger_data;
38 e2sm_event_trigger_helper trigger_recv;
40 e2sm_event_trigger mem_check; // just null declaration to test memory
42 e2sm_event_trigger e2sm_event_trigger;
43 E2N_E2SM_gNB_X2_eventTriggerDefinition_t *event; // used for decoding
46 SECTION("Encoding event trigger, positive and negative cases"){
49 trigger_data.egNB_id = "hello world";
50 trigger_data.plmn_id = "something new";
51 trigger_data.egNB_id_type = 2;
52 trigger_data.interface_direction = 1;
54 trigger_data.procedure_code = 27;
55 trigger_data.message_type = 0;
57 //Add multiple interface protocol ie items to cover all test cases ..
59 trigger_data.add_protocol_ie_item(1, 1, 1, 1);
60 trigger_data.add_protocol_ie_item(2, 2, 2, 2);
61 trigger_data.add_protocol_ie_item(3, 3, 3, 0);
62 trigger_data.add_protocol_ie_item(4, 3, 4, std::string("Something new"));
63 trigger_data.add_protocol_ie_item(4, 3, 5, std::string("Something old"));
65 res = e2sm_event_trigger.encode_event_trigger(&buf[0], &buf_size, trigger_data);
69 retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, (void**)&(event), &buf[0], buf_size);
71 REQUIRE(retval.code == RC_OK);
72 res = e2sm_event_trigger.get_fields(event, trigger_recv);
74 REQUIRE(trigger_recv.interface_direction == trigger_data.interface_direction);
75 REQUIRE(trigger_recv.procedure_code == trigger_data.procedure_code);
76 REQUIRE(trigger_recv.message_type == trigger_data.message_type);
77 REQUIRE(trigger_recv.plmn_id == "som");
78 REQUIRE(trigger_recv.get_list()->size() == trigger_data.get_list()->size());
79 ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event);
81 // buffer size too low
83 res = e2sm_event_trigger.encode_event_trigger(&buf[0], &buf_size, trigger_data);
84 REQUIRE(res == false);
86 // invalid constraints ...
87 trigger_data.interface_direction = 10;
89 res = e2sm_event_trigger.encode_event_trigger(&buf[0], &buf_size, trigger_data);
90 REQUIRE(res == false);
98 TEST_CASE("E2SM Indication Header", "e2sm_header"){
100 unsigned char buf_header[128];
101 unsigned char buf_msg[1024];
102 size_t header_size = 128;
103 size_t msg_size = 1024;
105 std::string test_x2ap_message = "This is X2AP !";
108 asn_dec_rval_t retval;
109 e2sm_indication e2sm_builder;
110 e2sm_indication e2sm_receiver;
112 SECTION("Indication Header encoding/decoding"){
113 e2sm_header_helper header_tx;
115 e2sm_header_helper header_re;
117 header_tx.egNB_id="hello";
118 header_tx.plmn_id="there";
119 header_tx.interface_direction = 1;
120 header_tx.egNB_id_type = 2;
122 // Encode the message
123 res = e2sm_builder.encode_indication_header(&buf_header[0], &header_size, header_tx);
124 REQUIRE(res == true);
127 E2N_E2SM_gNB_X2_indicationHeader_t *header = 0; // used for decoding
128 retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, (void**)&(header), &buf_header[0], header_size);
130 REQUIRE(retval.code == RC_OK);
132 res = e2sm_receiver.get_header_fields(header, header_re);
133 REQUIRE(res == true);
135 REQUIRE(header_re.plmn_id == "the");
136 ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, header);
138 // buffer size too low
140 res = e2sm_builder.encode_indication_header(&buf_header[0], &header_size, header_tx);
141 REQUIRE(res == false);
143 // invalid constraints ...
144 header_tx.interface_direction = 10;
146 res = e2sm_builder.encode_indication_header(&buf_header[0], &header_size, header_tx);
147 REQUIRE(res == false);
152 SECTION("Indication Message encoding/decoding"){
154 e2sm_message_helper message_tx;
155 e2sm_message_helper message_re;
157 message_tx.x2ap_pdu = (unsigned char *)calloc(1024, sizeof(unsigned char));
158 memcpy(message_tx.x2ap_pdu, test_x2ap_message.c_str(), test_x2ap_message.length());
159 message_tx.x2ap_pdu_size = test_x2ap_message.length();
162 res = e2sm_builder.encode_indication_message(&buf_msg[0], &msg_size, message_tx);
163 REQUIRE(res == true);
165 E2N_E2SM_gNB_X2_indicationMessage_t *message = 0; // used for decoding
167 retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, (void**)&(message), &buf_msg[0], msg_size);
169 REQUIRE(retval.code == RC_OK);
170 res = e2sm_receiver.get_message_fields(message, message_re);
171 REQUIRE(res == true);
173 REQUIRE(message_re.x2ap_pdu_size == message_tx.x2ap_pdu_size);
174 ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, message);
175 free(message_tx.x2ap_pdu);
183 TEST_CASE("E2SM Encoding/Decoding", "Control"){
185 unsigned char buf_header[128];
186 unsigned char buf_msg[1024];
187 size_t header_size = 128;
188 size_t msg_size = 1024;
190 e2sm_control e2sm_builder;
191 e2sm_header_helper header_tx;
192 e2sm_message_helper message_tx;
195 e2sm_control e2sm_receiver;
196 e2sm_header_helper header_re;
197 e2sm_message_helper message_re;
201 asn_dec_rval_t retval;
203 E2N_E2SM_gNB_X2_controlHeader_t *header; // used for decoding
204 E2N_E2SM_gNB_X2_controlMessage_t *message; // used for decoding
206 SECTION("Control encoding/decoding header"){
208 header_tx.egNB_id="hello";
209 header_tx.plmn_id="there";
210 header_tx.interface_direction = 1;
211 header_tx.egNB_id_type = 2;
214 res = e2sm_builder.encode_control_header(&buf_header[0], &header_size, header_tx);
215 REQUIRE(res == true);
217 // =================================
218 // Decode the message
220 retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_controlHeader, (void**)&(header), &buf_header[0], header_size);
222 REQUIRE(retval.code == RC_OK);
224 res = e2sm_receiver.get_header_fields(header, header_re);
225 REQUIRE(res == true);
226 REQUIRE(header_re.plmn_id == "the");
227 REQUIRE(header_re.interface_direction == header_tx.interface_direction);
229 // free the struct since we have already extracted all references
230 ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_controlHeader, header);
233 SECTION("Control message encoding/decoding"){
235 std::string test_x2ap_message = "This is X2AP !";
237 message_tx.x2ap_pdu = (unsigned char *)calloc(1024, sizeof(unsigned char));
238 memcpy(message_tx.x2ap_pdu, test_x2ap_message.c_str(), test_x2ap_message.length());
239 message_tx.x2ap_pdu_size = test_x2ap_message.length();
241 res = e2sm_builder.encode_control_message(&buf_msg[0], &msg_size, message_tx);
242 REQUIRE(res == true);
246 retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_controlMessage, (void**)&(message), &buf_msg[0], msg_size);
248 REQUIRE(retval.code == RC_OK);
249 res = e2sm_receiver.get_message_fields(message, message_re);
250 REQUIRE(res == true);
251 REQUIRE(message_re.x2ap_pdu_size == message_tx.x2ap_pdu_size);
252 ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_controlMessage, message);
253 free(message_tx.x2ap_pdu);