test/unit_test_subscription.cc

   1 /*
   2 ==================================================================================
   3
   4         Copyright (c) 2018-2019 AT&T Intellectual Property.
   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 /* Author : Ashwin Sridharan
  20    Date    : Feb 2019
  21 */
  22
  23
  24
  25 #define CATCH_CONFIG_MAIN
  26 #include <catch2/catch.hpp>
  27 #include <iostream>
  28 #include <subscription_request.hpp>
  29 #include <subscription_response.hpp>
  30 #include <subscription_delete_request.hpp>
  31 #include <subscription_delete_response.hpp>
  32 #include <chrono>
  33
  34 #define BUFFER_SIZE 1024
  35
  36
  37 TEST_CASE("E2AP PDU Subscription", "RIC Susbcription/Deletion Requests"){
  38
  39   subscription_helper  din;
  40   subscription_helper  dout;
  41
  42   subscription_request sub_req;
  43   subscription_request sub_recv;
  44
  45   subscription_delete sub_del_req;
  46   subscription_delete sub_del_recv;
  47
  48   unsigned char buf[BUFFER_SIZE];
  49   size_t buf_size = BUFFER_SIZE;
  50   bool res;
  51
  52   mdclog_attr_t *attr;
  53   mdclog_attr_init(&attr);
  54   mdclog_attr_set_ident(attr, "UNIT TEST SUBSCRIPTION");
  55   mdclog_init(attr);
  56   mdclog_level_set(MDCLOG_INFO);
  57   mdclog_attr_destroy(attr);
  58
  59
  60   //=========================================================
  61   SECTION ("Verifiy request PDU generation"){
  62
  63     din.clear();
  64     dout.clear();
  65
  66
  67     //Random Data  for request
  68     int request_id = 2;
  69     int req_seq_no = 1;
  70     int function_id = 0;
  71     std::string event_def = "This is a test";
  72
  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());
  76
  77     // fail if no actions specified
  78     res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
  79     REQUIRE(res == false);
  80
  81     // variable number of actions
  82     int num_actions = 17;
  83     srand(9384938);
  84
  85     for(int num_act = 1; num_act < num_actions; num_act ++){
  86
  87       din.clear();
  88       for(int i = 0; i < num_act; i++){
  89         int type = rand() % 3;
  90         din.add_action(i, type, "test", 1, 1);
  91       }
  92
  93       buf_size = BUFFER_SIZE;
  94       res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
  95       if(!res)
  96         std::cerr <<"Error = " << sub_req.get_error() << " with actions = " << din.get_list()->size() << std::endl;
  97       REQUIRE(res == true);
  98     }
  99
 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);
 107
 108   //=========================================================
 109
 110   }
 111
 112   SECTION ("Verify request PDU decoding"){
 113
 114     //Random Data  for request
 115     int request_id = 2;
 116     int req_seq_no = 1;
 117     int function_id = 0;
 118     std::string event_def = "This is a test";
 119
 120
 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());
 124
 125     srand(9384938);
 126
 127     int num_actions = 17;
 128     for(int num_act = 1; num_act < num_actions; num_act ++){
 129
 130       din.clear();
 131       dout.clear();
 132
 133       for(int i = 0; i < num_act; i++){
 134         int type = rand() % 3;
 135         din.add_action(i, type);
 136       }
 137
 138       buf_size = BUFFER_SIZE;
 139       res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size,  din);
 140       REQUIRE(res == true);
 141
 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);
 145
 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);
 154
 155       ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
 156     }
 157
 158   }
 159
 160   SECTION ("Verify Error on illegal values in request"){
 161     din.clear();
 162     dout.clear();
 163
 164      //Random Data  for request
 165     int request_id = 2;
 166     int req_seq_no = 1;
 167     int function_id = 6000;
 168     std::string event_def = "This is a test";
 169
 170
 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());
 174
 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);
 179   }
 180
 181   SECTION("Verify Error on illegal input in request"){
 182     res = sub_req.get_fields(NULL, dout);
 183     REQUIRE(res == false);
 184   }
 185
 186
 187
 188   SECTION ("Verifiy delete request PDU generation"){
 189
 190     //Random Data  for request
 191     din.clear();
 192     dout.clear();
 193     int request_id = 2;
 194     int req_seq_no = 1;
 195     int function_id = 0;
 196
 197     din.set_request(request_id, req_seq_no);
 198     din.set_function_id(function_id);
 199
 200     res = sub_del_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
 201     REQUIRE(res == true);
 202
 203   }
 204
 205   SECTION ("Verify delete request PDU decoding"){
 206     din.clear();
 207     dout.clear();
 208
 209     //Random Data  for request
 210     int request_id = 2;
 211     int req_seq_no = 1;
 212     int function_id = 0;
 213
 214     din.set_request(request_id, req_seq_no);
 215     din.set_function_id(function_id);
 216
 217     res = sub_del_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
 218
 219     REQUIRE(res == true);
 220
 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);
 224
 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());
 229
 230     ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
 231   }
 232
 233   SECTION ("Verify Error on illegal values in delete request"){
 234     din.clear();
 235     dout.clear();
 236
 237      //Random Data  for request
 238     int request_id = 2;
 239     int req_seq_no = 1;
 240     int function_id = 6000;
 241
 242     din.set_request(request_id, req_seq_no);
 243     din.set_function_id(function_id);
 244
 245     res = sub_del_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
 246
 247     REQUIRE(res == false);
 248   }
 249
 250   SECTION("Verify Error on illegal input in delete request"){
 251     res = sub_del_req.get_fields(NULL, dout);
 252     REQUIRE(res == false);
 253   }
 254
 255 }
 256
 257 TEST_CASE("E2AP PDU Subscription Response", "RIC Subscription/Deletion Responses"){
 258   subscription_response_helper  din;
 259   subscription_response_helper  dout;
 260
 261   subscription_response sub_resp;
 262   subscription_response sub_recv;
 263
 264   subscription_delete_response sub_del_resp;
 265   subscription_delete_response sub_del_recv;
 266
 267   unsigned char buf[BUFFER_SIZE];
 268   size_t buf_size = BUFFER_SIZE;
 269   bool res;
 270
 271   //=========================================================
 272   SECTION ("Verifiy successful/unsuccessful response PDU generation"){
 273
 274     din.clear();
 275     dout.clear();
 276
 277     //Random Data  for request
 278     int request_id = 2;
 279     int req_seq_no = 1;
 280     int function_id = 0;
 281
 282     din.set_request(request_id, req_seq_no);
 283     din.set_function_id(function_id);
 284
 285
 286     // variable number of actions
 287     int num_actions = 25;
 288     din.clear();
 289     srand(9384938);
 290     for(int num_success = 0; num_success <= num_actions; num_success ++){
 291       for(int num_failures = 0; num_failures <= num_actions; num_failures++){
 292         din.clear();
 293         for(int i = 0; i < num_success; i++){
 294           din.add_action(i);
 295         }
 296         for(int j = 0; j < num_failures; j++){
 297           int cause = 1;
 298           int sub_cause = 1;
 299           din.add_action(j, cause, sub_cause);
 300         }
 301
 302         //std::cout <<"Successful admitted actions = " << num_success << " Unsuccessful admitted actions = " << num_failures << std::endl;
 303
 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);
 308         }
 309         else{
 310           REQUIRE(res == true);
 311         }
 312
 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);
 317         }
 318         else{
 319           REQUIRE(res == true);
 320         }
 321       }
 322     }
 323   }
 324
 325
 326
 327 //   //=========================================================
 328
 329
 330
 331   SECTION ("Verify successful response PDU decoding"){
 332     //Random Data  for request
 333     int request_id = 2;
 334     int req_seq_no = 1;
 335     int function_id = 0;
 336
 337     din.set_request(request_id, req_seq_no);
 338     din.set_function_id(function_id);
 339
 340
 341     // variable number of actions
 342     int num_actions = 16;
 343     din.clear();
 344     srand(9384938);
 345     for(int num_success = 1; num_success <= num_actions; num_success ++){
 346       for(int num_failures = 0; num_failures <= num_actions; num_failures++){
 347         din.clear();
 348         dout.clear();
 349         for(int i = 0; i < num_success; i++){
 350           din.add_action(i);
 351         }
 352         for(int j = 0; j < num_failures; j++){
 353           int cause = 1;
 354           int sub_cause = 1;
 355           din.add_action(j, cause, sub_cause);
 356         }
 357
 358
 359         buf_size = BUFFER_SIZE;
 360         res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, true);
 361         REQUIRE(res == true);
 362
 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);
 366
 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());
 373
 374         ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
 375       }
 376     }
 377   }
 378
 379   SECTION ("Verify unsuccessful response PDU decoding"){
 380     //Random Data  for request
 381     int request_id = 2;
 382     int req_seq_no = 1;
 383     int function_id = 0;
 384
 385     din.set_request(request_id, req_seq_no);
 386     din.set_function_id(function_id);
 387
 388
 389     // variable number of actions
 390     int num_actions = 16;
 391     din.clear();
 392     srand(9384938);
 393     for(int num_failures = 1; num_failures <= num_actions; num_failures++){
 394       din.clear();
 395       dout.clear();
 396
 397       for(int j = 0; j < num_failures; j++){
 398         int cause = 1;
 399         int sub_cause = 1;
 400         din.add_action(j, cause, sub_cause);
 401       }
 402
 403
 404       buf_size = BUFFER_SIZE;
 405       res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, false);
 406       REQUIRE(res == true);
 407
 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);
 411
 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());
 417
 418       ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
 419     }
 420
 421   }
 422
 423   SECTION ("Verify Error on illegal values in response"){
 424     //Random Data  for request
 425     int request_id = 2;
 426     int req_seq_no = 1;
 427     int function_id = 6000;
 428
 429
 430     din.set_request(request_id, req_seq_no);
 431     din.set_function_id(function_id);
 432
 433     din.add_action(0);
 434     din.add_action(11, 2, 1);
 435
 436     buf_size = BUFFER_SIZE;
 437     res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, true);
 438     REQUIRE(res == false);
 439
 440     buf_size = BUFFER_SIZE;
 441     res = sub_resp.encode_e2ap_subscription_response(&buf[0], &buf_size, din, false);
 442     REQUIRE(res == false);
 443
 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));
 448   }
 449
 450
 451   SECTION ("Verifiy successful/unsuccessful  delete response PDU generation"){
 452
 453     //Random Data  for request
 454     din.clear();
 455     dout.clear();
 456
 457     int request_id = 2;
 458     int req_seq_no = 1;
 459     int function_id = 0;
 460
 461
 462     din.set_request(request_id, req_seq_no);
 463     din.set_function_id(function_id);
 464
 465     res = sub_del_resp.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, true);
 466     REQUIRE(res == true);
 467
 468     res = sub_del_resp.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, false);
 469     REQUIRE(res == true);
 470
 471    }
 472
 473   SECTION ("Verify successful delete response PDU decoding"){
 474     din.clear();
 475     dout.clear();
 476
 477     //Random Data  for request
 478     int request_id = 2;
 479     int req_seq_no = 1;
 480     int function_id = 0;
 481
 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);
 486
 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);
 490
 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());
 495
 496     ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_recv);
 497   }
 498
 499   SECTION("Verify unsuccessful delete response PDU decoding"){
 500
 501     din.clear();
 502     dout.clear();
 503
 504     //Random Data  for request
 505     int request_id = 2;
 506     int req_seq_no = 1;
 507     int function_id = 0;
 508
 509     din.set_request(request_id, req_seq_no);
 510     din.set_function_id(function_id);
 511
 512     res = sub_del_recv.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, false);
 513     REQUIRE(res == true);
 514
 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);
 518
 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);
 524   }
 525
 526   SECTION ("Verify Error on illegal values in delete response"){
 527      //Random Data  for request
 528     int request_id = 2;
 529     int req_seq_no = 1;
 530     int function_id = 6000;
 531
 532
 533     din.set_request(request_id, req_seq_no);
 534     din.set_function_id(function_id);
 535
 536     din.add_action(0);
 537     din.add_action(11, 2, 1);
 538     res = sub_del_resp.encode_e2ap_subscription_delete_response(&buf[0], &buf_size, din, true);
 539
 540     REQUIRE(res == false);
 541   }
 542
 543
 544 }
 545
 546