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 ==================================================================================
19 /* Author : Ashwin Sridharan
25 #define CATCH_CONFIG_MAIN
26 #include <catch2/catch.hpp>
28 #include <subscription_request.hpp>
29 #include <subscription_response.hpp>
30 #include <subscription_delete_request.hpp>
31 #include <subscription_delete_response.hpp>
34 #define BUFFER_SIZE 1024
37 TEST_CASE("E2AP PDU Subscription", "RIC Susbcription/Deletion Requests"){
39 subscription_helper din;
40 subscription_helper dout;
42 subscription_request sub_req;
43 subscription_request sub_recv;
45 subscription_delete sub_del_req;
46 subscription_delete sub_del_recv;
48 unsigned char buf[BUFFER_SIZE];
49 size_t buf_size = BUFFER_SIZE;
53 mdclog_attr_init(&attr);
54 mdclog_attr_set_ident(attr, "UNIT TEST SUBSCRIPTION");
56 mdclog_level_set(MDCLOG_INFO);
57 mdclog_attr_destroy(attr);
60 //=========================================================
61 SECTION ("Verifiy request PDU generation"){
67 //Random Data for request
71 std::string event_def = "This is a test";
73 din.set_request(request_id, req_seq_no);
74 din.set_function_id(function_id);
75 din.set_event_def(event_def.c_str(), event_def.length());
77 // fail if no actions specified
78 res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
79 REQUIRE(res == false);
81 // variable number of actions
85 for(int num_act = 1; num_act < num_actions; num_act ++){
88 for(int i = 0; i < num_act; i++){
89 int type = rand() % 3;
90 din.add_action(i, type);
93 buf_size = BUFFER_SIZE;
94 res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
96 std::cerr <<"Error = " << sub_req.get_error() << " with actions = " << din.get_list()->size() << std::endl;
100 // Adding another action should result in
101 // encoding error since according to specs v-0.31
102 // maxRICactionID == 16
103 din.add_action(26, 0);
104 buf_size = BUFFER_SIZE;
105 res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
106 REQUIRE(res == false);
108 //=========================================================
112 SECTION ("Verify request PDU decoding"){
114 //Random Data for request
118 std::string event_def = "This is a test";
121 din.set_request(request_id, req_seq_no);
122 din.set_function_id(function_id);
123 din.set_event_def(event_def.c_str(), event_def.length());
127 int num_actions = 17;
128 for(int num_act = 1; num_act < num_actions; num_act ++){
133 for(int i = 0; i < num_act; i++){
134 int type = rand() % 3;
135 din.add_action(i, type);
138 buf_size = BUFFER_SIZE;
139 res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
140 REQUIRE(res == true);
142 E2N_E2AP_PDU_t *e2ap_recv = 0;
143 asn_dec_rval_t retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&(e2ap_recv), &buf[0], buf_size);
144 REQUIRE(retval.code == RC_OK);
146 sub_recv.get_fields(e2ap_recv->choice.initiatingMessage, dout);
147 REQUIRE(dout.get_request_id() == din.get_request_id());
148 REQUIRE(dout.get_req_seq() == din.get_req_seq());
149 REQUIRE(dout.get_function_id() == din.get_function_id());
150 REQUIRE(dout.get_list()->size() == din.get_list()->size());
151 std::string dout_string((const char *)dout.get_event_def(), dout.get_event_def_size());
152 std::string din_string((const char *)din.get_event_def(), din.get_event_def_size());
153 REQUIRE(dout_string == din_string);
155 ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
160 SECTION ("Verify Error on illegal values in request"){
164 //Random Data for request
167 int function_id = 6000;
168 std::string event_def = "This is a test";
171 din.set_request(request_id, req_seq_no);
172 din.set_function_id(function_id);
173 din.set_event_def(event_def.c_str(), event_def.length());
175 din.add_action(0, 0);
176 din.add_action(11, 1);
177 res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
178 REQUIRE(res == false);
181 SECTION("Verify Error on illegal input in request"){
182 res = sub_req.get_fields(NULL, dout);
183 REQUIRE(res == false);
188 SECTION ("Verifiy delete request PDU generation"){
190 //Random Data for request
197 din.set_request(request_id, req_seq_no);
198 din.set_function_id(function_id);
200 res = sub_del_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
201 REQUIRE(res == true);
205 SECTION ("Verify delete request PDU decoding"){
209 //Random Data for request
214 din.set_request(request_id, req_seq_no);
215 din.set_function_id(function_id);
217 res = sub_del_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
219 REQUIRE(res == true);
221 E2N_E2AP_PDU_t *e2ap_recv = 0;
222 asn_dec_rval_t retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&(e2ap_recv), &buf[0], buf_size);
223 REQUIRE(retval.code == RC_OK);
225 sub_del_recv.get_fields(e2ap_recv->choice.initiatingMessage, dout);
226 REQUIRE(dout.get_request_id() == din.get_request_id());
227 REQUIRE(dout.get_req_seq() == din.get_req_seq());
228 REQUIRE(dout.get_function_id() == din.get_function_id());
230 ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
233 SECTION ("Verify Error on illegal values in delete request"){
237 //Random Data for request
240 int function_id = 6000;
242 din.set_request(request_id, req_seq_no);
243 din.set_function_id(function_id);
245 res = sub_del_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
247 REQUIRE(res == false);
250 SECTION("Verify Error on illegal input in delete request"){
251 res = sub_del_req.get_fields(NULL, dout);
252 REQUIRE(res == false);
257 TEST_CASE("E2AP PDU Subscription Response", "RIC Subscription/Deletion Responses"){
258 subscription_response_helper din;
259 subscription_response_helper dout;
261 subscription_response sub_resp;
262 subscription_response sub_recv;
264 subscription_delete_response sub_del_resp;
265 subscription_delete_response sub_del_recv;
267 unsigned char buf[BUFFER_SIZE];
268 size_t buf_size = BUFFER_SIZE;
271 //=========================================================
272 SECTION ("Verifiy successful/unsuccessful response PDU generation"){
277 //Random Data for request
282 din.set_request(request_id, req_seq_no);
283 din.set_function_id(function_id);
286 // variable number of actions
287 int num_actions = 25;
290 for(int num_success = 0; num_success <= num_actions; num_success ++){
291 for(int num_failures = 0; num_failures <= num_actions; num_failures++){
293 for(int i = 0; i < num_success; i++){
296 for(int j = 0; j < num_failures; j++){
299 din.add_action(j, cause, sub_cause);
302 //std::cout <<"Successful admitted actions = " << num_success << " Unsuccessful admitted actions = " << num_failures << std::endl;
304 buf_size = BUFFER_SIZE;
305 res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, true);
306 if(num_success == 0 || num_success > 16 || num_failures > 16){
307 REQUIRE(res == false);
310 REQUIRE(res == true);
313 buf_size = BUFFER_SIZE;
314 res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, false);
315 if(num_failures == 0 || num_failures > 16){
316 REQUIRE(res == false);
319 REQUIRE(res == true);
327 // //=========================================================
331 SECTION ("Verify successful response PDU decoding"){
332 //Random Data for request
337 din.set_request(request_id, req_seq_no);
338 din.set_function_id(function_id);
341 // variable number of actions
342 int num_actions = 16;
345 for(int num_success = 1; num_success <= num_actions; num_success ++){
346 for(int num_failures = 0; num_failures <= num_actions; num_failures++){
349 for(int i = 0; i < num_success; i++){
352 for(int j = 0; j < num_failures; j++){
355 din.add_action(j, cause, sub_cause);
359 buf_size = BUFFER_SIZE;
360 res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, true);
361 REQUIRE(res == true);
363 E2N_E2AP_PDU_t *e2ap_recv = 0;
364 asn_dec_rval_t retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&(e2ap_recv), &buf[0], buf_size);
365 REQUIRE(retval.code == RC_OK);
367 sub_recv.get_fields(e2ap_recv->choice.successfulOutcome, dout);
368 REQUIRE(dout.get_request_id() == din.get_request_id());
369 REQUIRE(dout.get_req_seq() == din.get_req_seq());
370 REQUIRE(dout.get_function_id() == din.get_function_id());
371 REQUIRE(dout.get_admitted_list()->size() == din.get_admitted_list()->size());
372 REQUIRE(dout.get_not_admitted_list()->size() == din.get_not_admitted_list()->size());
374 ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
379 SECTION ("Verify unsuccessful response PDU decoding"){
380 //Random Data for request
385 din.set_request(request_id, req_seq_no);
386 din.set_function_id(function_id);
389 // variable number of actions
390 int num_actions = 16;
393 for(int num_failures = 1; num_failures <= num_actions; num_failures++){
397 for(int j = 0; j < num_failures; j++){
400 din.add_action(j, cause, sub_cause);
404 buf_size = BUFFER_SIZE;
405 res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, false);
406 REQUIRE(res == true);
408 E2N_E2AP_PDU_t *e2ap_recv = 0;
409 asn_dec_rval_t retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&(e2ap_recv), &buf[0], buf_size);
410 REQUIRE(retval.code == RC_OK);
412 sub_recv.get_fields(e2ap_recv->choice.unsuccessfulOutcome, dout);
413 REQUIRE(dout.get_request_id() == din.get_request_id());
414 REQUIRE(dout.get_req_seq() == din.get_req_seq());
415 REQUIRE(dout.get_function_id() == din.get_function_id());
416 REQUIRE(dout.get_not_admitted_list()->size() == din.get_not_admitted_list()->size());
418 ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
423 SECTION ("Verify Error on illegal values in response"){
424 //Random Data for request
427 int function_id = 6000;
430 din.set_request(request_id, req_seq_no);
431 din.set_function_id(function_id);
434 din.add_action(11, 2, 1);
436 buf_size = BUFFER_SIZE;
437 res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, true);
438 REQUIRE(res == false);
440 buf_size = BUFFER_SIZE;
441 res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, false);
442 REQUIRE(res == false);
444 //SuccessfulOutcome_t * success_msg = NULL;
445 //UnsuccessfulOutcome_t * unsuccess_msg = NULL;
446 //REQUIRE_THROWS(sub_resp.get_fields(success_msg, din));
447 //REQUIRE_THROWS(sub_resp.get_fields(unsuccess_msg, din));
451 SECTION ("Verifiy successful/unsuccessful delete response PDU generation"){
453 //Random Data for request
462 din.set_request(request_id, req_seq_no);
463 din.set_function_id(function_id);
465 res = sub_del_resp.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, true);
466 REQUIRE(res == true);
468 res = sub_del_resp.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, false);
469 REQUIRE(res == true);
473 SECTION ("Verify successful delete response PDU decoding"){
477 //Random Data for request
482 din.set_request(request_id, req_seq_no);
483 din.set_function_id(function_id);
484 res = sub_del_recv.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, true);
485 REQUIRE(res == true);
487 E2N_E2AP_PDU_t *e2ap_recv = 0;
488 asn_dec_rval_t retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&(e2ap_recv), &buf[0], buf_size);
489 REQUIRE(retval.code == RC_OK);
491 sub_recv.get_fields(e2ap_recv->choice.successfulOutcome, dout);
492 REQUIRE(dout.get_request_id() == din.get_request_id());
493 REQUIRE(dout.get_req_seq() == din.get_req_seq());
494 REQUIRE(dout.get_function_id() == din.get_function_id());
496 ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
499 SECTION("Verify unsuccessful delete response PDU decoding"){
504 //Random Data for request
509 din.set_request(request_id, req_seq_no);
510 din.set_function_id(function_id);
512 res = sub_del_recv.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, false);
513 REQUIRE(res == true);
515 E2N_E2AP_PDU_t *e2ap_recv = 0;
516 asn_dec_rval_t retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&(e2ap_recv), &buf[0], buf_size);
517 REQUIRE(retval.code == RC_OK);
519 sub_recv.get_fields(e2ap_recv->choice.unsuccessfulOutcome, dout);
520 REQUIRE(dout.get_request_id() == din.get_request_id());
521 REQUIRE(dout.get_req_seq() == din.get_req_seq());
522 REQUIRE(dout.get_function_id() == din.get_function_id());
523 ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
526 SECTION ("Verify Error on illegal values in delete response"){
527 //Random Data for request
530 int function_id = 6000;
533 din.set_request(request_id, req_seq_no);
534 din.set_function_id(function_id);
537 din.add_action(11, 2, 1);
538 res = sub_del_resp.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, true);
540 REQUIRE(res == false);