test/unit_test_sgnb_addition_request.cc

   1 /*\r
   2 ==================================================================================\r
   3 \r
   4    Copyright (c) 2018-2019 AT&T Intellectual Property.\r
   5 \r
   6    Licensed under the Apache License, Version 2.0 (the "License");\r
   7    you may not use this file except in compliance with the License.\r
   8    You may obtain a copy of the License at\r
   9 \r
  10    http://www.apache.org/licenses/LICENSE-2.0\r
  11 \r
  12    Unless required by applicable law or agreed to in writing, software\r
  13    distributed under the License is distributed on an "AS IS" BASIS,\r
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  15    See the License for the specific language governing permissions and\r
  16    limitations under the License.\r
  17 ==================================================================================\r
  18 */\r
  19 /*\r
  20  * unit_test_sgnb_add_request.cc\r
  21  *\r
  22  *  Created on: Sep 9, 2019\r
  23  *      Author: sjana\r
  24  */\r
  25 \r
  26 #define CATCH_CONFIG_MAIN\r
  27 #include <sgnb_addition_request.hpp>\r
  28 #include <sgnb_addition_response.hpp>\r
  29 #include <mdclog/mdclog.h>\r
  30 #include <catch2/catch.hpp>\r
  31 \r
  32 #define BUFFER_SIZE 2048\r
  33 TEST_CASE("X2AP PDUs", "[X2AP SgNB Addition Request]"){\r
  34   \r
  35   mdclog_attr_t *attr;\r
  36   mdclog_attr_init(&attr);\r
  37   mdclog_attr_set_ident(attr, "UNIT TEST XAPP FRAMEWORK");\r
  38   mdclog_init(attr);\r
  39   mdclog_level_set(MDCLOG_DEBUG);\r
  40   mdclog_attr_destroy(attr);\r
  41   \r
  42   bool res;\r
  43         \r
  44   sgnb_addition_helper encode_data;\r
  45   sgnb_addition_helper decode_data;\r
  46 \r
  47   sgnb_addition_request memcheck_req;\r
  48   sgnb_addition_request encode_test;\r
  49   sgnb_addition_request decode_test;\r
  50   unsigned char buf[BUFFER_SIZE];\r
  51   size_t buf_size = BUFFER_SIZE;\r
  52 \r
  53   sgnb_addition_response memcheck_resp; \r
  54   sgnb_addition_response resp_out;\r
  55   \r
  56   unsigned char data_buf[BUFFER_SIZE];\r
  57   size_t data_size = BUFFER_SIZE;\r
  58 \r
  59   // sgnb data creation static parameters\r
  60   unsigned char enc_alg[] = "Bl";\r
  61   unsigned char integrity_alg[] = "md";\r
  62   unsigned char  sgnb_security_key[] = "12345678912345678912345678912345";\r
  63   unsigned char  mesgnb_container[] = "Information";\r
  64   unsigned char transport_layer_addr[] = "AABBCCDDEE";\r
  65   unsigned char gtp_tei[] = "ZZYX";\r
  66   unsigned char plmn[] = "321";\r
  67   unsigned char eutran[] = "4567";\r
  68 \r
  69   SECTION("Verify encoding/decoding of valid data with variable number of erabs"){\r
  70 \r
  71     encode_data.menb_ue_x2ap_id = 12;\r
  72     encode_data.sgnb_ue_x2ap_id = 10;\r
  73 \r
  74     encode_data.bit_rate_max_up = 1000;\r
  75     encode_data.bit_rate_max_dn = 2000;\r
  76 \r
  77     encode_data.encryption_algs = enc_alg;\r
  78     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
  79     encode_data.encryption_algs_unused = 0;\r
  80 \r
  81     encode_data.integrity_protection_algs = integrity_alg;\r
  82     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
  83     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
  84     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
  85 \r
  86 \r
  87     encode_data.sgnb_security_key = sgnb_security_key;\r
  88     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
  89     encode_data.sgnb_security_key_unused = 0;\r
  90     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
  91 \r
  92 \r
  93     encode_data.menb_sgnb_container = mesgnb_container;\r
  94     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
  95 \r
  96     encode_data.plmn_identity = plmn;\r
  97     encode_data.plmn_identity_size = strlen((char *)plmn);\r
  98 \r
  99     encode_data.eutran_identifier = eutran;\r
 100     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 101     encode_data.eutran_identifier_unused = 4;\r
 102 \r
 103     REQUIRE(encode_data.eutran_identifier_size*8 - encode_data.eutran_identifier_unused == 28);\r
 104     encode_data.subscriber_profile_id = 34;\r
 105 \r
 106     std::vector<erab_item> * ref_array = encode_data.get_list();\r
 107     int max_erabs = 30;\r
 108     srand(12093021);\r
 109 \r
 110     // pdpc present\r
 111     for(int num_erabs = 1; num_erabs < max_erabs; num_erabs++){\r
 112 \r
 113       ref_array->clear();\r
 114     \r
 115     \r
 116       for(int i = 0; i < num_erabs; i++){\r
 117       \r
 118         ref_array->emplace_back();\r
 119         (*ref_array)[i].erab_id = rand() %15;\r
 120         (*ref_array)[i].drb_id = i%32 + 1;\r
 121         (*ref_array)[i].pdcp_at_sgnb = 1;\r
 122         (*ref_array)[i].mcg_resources = 1;\r
 123         (*ref_array)[i].scg_resources = 1;\r
 124         (*ref_array)[i].sgnb_pdcp_present = 1;\r
 125         \r
 126         // element sgnb present\r
 127         (*ref_array)[i].sgnb_item.qci = 8;\r
 128         (*ref_array)[i].sgnb_item.priority_level = 8;\r
 129         (*ref_array)[i].sgnb_item.pre_emption_capability = 0;\r
 130         (*ref_array)[i].sgnb_item.pre_emption_vulnerability = 1;\r
 131         (*ref_array)[i].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 132         (*ref_array)[i].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 133         (*ref_array)[i].sgnb_item.gtp_tei = gtp_tei;\r
 134         (*ref_array)[i].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 135         (*ref_array)[i].sgnb_item.rlc_mode = 1;\r
 136         \r
 137       }\r
 138       buf_size = BUFFER_SIZE;\r
 139       res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 140       REQUIRE(res == true);\r
 141 \r
 142       // std::string out_file = std::string("X2AP-PDU-SgNBAdditionRequest-NumErabs-") + std::to_string(num_erabs) + std::string(".per");\r
 143       // FILE *pfile = fopen(out_file.c_str(), "w");\r
 144       // fwrite(buf, sizeof(char), buf_size, pfile);\r
 145       // fclose(pfile);\r
 146 \r
 147       // How many times we test decoding the same data\r
 148       int num_tests = 10;\r
 149       for(int i = 0; i < num_tests; i++){\r
 150         decode_data.clear();\r
 151         \r
 152         X2N_X2AP_PDU_t *x2ap_pdu_obj = 0;\r
 153         asn_dec_rval_t rval = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_X2N_X2AP_PDU, (void**)&x2ap_pdu_obj, buf, buf_size);\r
 154         REQUIRE(rval.code == RC_OK);\r
 155         \r
 156         res = decode_test.get_fields(x2ap_pdu_obj->choice.initiatingMessage, decode_data);\r
 157         REQUIRE(res==true);\r
 158         \r
 159         REQUIRE(decode_data.sgnb_security_key_size - decode_data.sgnb_security_key_unused == 32);\r
 160         REQUIRE(decode_data.eutran_identifier_size*8 - decode_data.eutran_identifier_unused == 28);\r
 161         REQUIRE(encode_data.get_list()->size() == decode_data.get_list()->size());\r
 162         REQUIRE(encode_data.erab_list[0].erab_id == decode_data.erab_list[0].erab_id);\r
 163         REQUIRE(encode_data.erab_list[0].drb_id == decode_data.erab_list[0].drb_id);\r
 164         REQUIRE(encode_data.erab_list[0].pdcp_at_sgnb == decode_data.erab_list[0].pdcp_at_sgnb);\r
 165         \r
 166         REQUIRE(encode_data.menb_ue_x2ap_id == decode_data.menb_ue_x2ap_id);\r
 167         REQUIRE(encode_data.bit_rate_max_up == decode_data.bit_rate_max_up);\r
 168         REQUIRE(encode_data.bit_rate_max_dn == decode_data.bit_rate_max_dn);\r
 169         REQUIRE(encode_data.subscriber_profile_id == decode_data.subscriber_profile_id);\r
 170         ASN_STRUCT_FREE(asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);\r
 171       }\r
 172       \r
 173     }\r
 174 \r
 175 \r
 176     // pdcp not present\r
 177     for(int num_erabs = 1; num_erabs < max_erabs; num_erabs++){\r
 178 \r
 179       ref_array->clear();\r
 180       \r
 181       for(int i = 0; i < num_erabs; i++){\r
 182       \r
 183         ref_array->emplace_back();\r
 184         (*ref_array)[i].erab_id = rand() %15;\r
 185         (*ref_array)[i].drb_id = i%32 + 1;\r
 186         (*ref_array)[i].pdcp_at_sgnb = 1;\r
 187         (*ref_array)[i].mcg_resources = 1;\r
 188         (*ref_array)[i].scg_resources = 1;\r
 189         (*ref_array)[i].sgnb_pdcp_present = 2;\r
 190         \r
 191         // element sgnb present\r
 192         (*ref_array)[i].sgnb_item.qci = 8;\r
 193         (*ref_array)[i].sgnb_item.priority_level = 8;\r
 194         (*ref_array)[i].sgnb_item.pre_emption_capability = 0;\r
 195         (*ref_array)[i].sgnb_item.pre_emption_vulnerability = 1;\r
 196         (*ref_array)[i].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 197         (*ref_array)[i].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 198         (*ref_array)[i].sgnb_item.gtp_tei = gtp_tei;\r
 199         (*ref_array)[i].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 200         (*ref_array)[i].sgnb_item.rlc_mode = 1;\r
 201         \r
 202       }\r
 203       \r
 204       buf_size = BUFFER_SIZE;\r
 205       res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 206       REQUIRE(res == true);\r
 207       \r
 208       // std::string out_file = std::string("X2AP-PDU-SgNBAdditionRequest-NoPDCP-NumErabs-") + std::to_string(num_erabs) + std::string(".per");\r
 209       // FILE *pfile = fopen(out_file.c_str(), "w");\r
 210       // fwrite(buf, sizeof(char), buf_size, pfile);\r
 211       // fclose(pfile);\r
 212       \r
 213       \r
 214       int num_tests = 10;\r
 215       for(int i = 0; i < num_tests; i++){\r
 216         decode_data.clear();\r
 217         \r
 218         X2N_X2AP_PDU_t *x2ap_pdu_obj = 0;\r
 219         asn_dec_rval_t rval = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_X2N_X2AP_PDU, (void**)&x2ap_pdu_obj, buf, buf_size);\r
 220         REQUIRE(rval.code == RC_OK);\r
 221         \r
 222         res = decode_test.get_fields(x2ap_pdu_obj->choice.initiatingMessage, decode_data);\r
 223         REQUIRE(res==true);\r
 224         \r
 225         REQUIRE(decode_data.sgnb_security_key_size - decode_data.sgnb_security_key_unused == 32);\r
 226         REQUIRE(decode_data.eutran_identifier_size*8 - decode_data.eutran_identifier_unused == 28);\r
 227         REQUIRE(encode_data.get_list()->size() == decode_data.get_list()->size());\r
 228         REQUIRE(encode_data.erab_list[0].erab_id == decode_data.erab_list[0].erab_id);\r
 229         REQUIRE(encode_data.erab_list[0].drb_id == decode_data.erab_list[0].drb_id);\r
 230         REQUIRE(encode_data.erab_list[0].pdcp_at_sgnb == decode_data.erab_list[0].pdcp_at_sgnb);\r
 231         \r
 232         REQUIRE(encode_data.menb_ue_x2ap_id == decode_data.menb_ue_x2ap_id);\r
 233         REQUIRE(encode_data.bit_rate_max_up == decode_data.bit_rate_max_up);\r
 234         REQUIRE(encode_data.bit_rate_max_dn == decode_data.bit_rate_max_dn);\r
 235         REQUIRE(encode_data.subscriber_profile_id == decode_data.subscriber_profile_id);\r
 236 \r
 237         ASN_STRUCT_FREE(asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);\r
 238       }\r
 239       \r
 240     }\r
 241     \r
 242   }\r
 243   \r
 244   SECTION("Encoding, invalid erab"){\r
 245 \r
 246     encode_data.menb_ue_x2ap_id = 12;\r
 247     encode_data.sgnb_ue_x2ap_id = 120;\r
 248 \r
 249     encode_data.bit_rate_max_up = 1000;\r
 250     encode_data.bit_rate_max_dn = 2000;\r
 251 \r
 252     encode_data.encryption_algs = enc_alg;\r
 253     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 254     encode_data.encryption_algs_unused = 0;\r
 255 \r
 256     encode_data.integrity_protection_algs = integrity_alg;\r
 257     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 258     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 259     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 260 \r
 261 \r
 262     encode_data.sgnb_security_key = sgnb_security_key;\r
 263     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 264     encode_data.sgnb_security_key_unused = 0;\r
 265     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 266 \r
 267 \r
 268     encode_data.menb_sgnb_container = mesgnb_container;\r
 269     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 270 \r
 271     encode_data.plmn_identity = plmn;\r
 272     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 273 \r
 274     encode_data.eutran_identifier = eutran;\r
 275     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 276     encode_data.eutran_identifier_unused = 4;\r
 277 \r
 278     REQUIRE(encode_data.eutran_identifier_size*8 - encode_data.eutran_identifier_unused == 28);\r
 279     encode_data.subscriber_profile_id = 34;\r
 280 \r
 281     std::vector<erab_item> * ref_array = encode_data.get_list();\r
 282     ref_array->clear();\r
 283     \r
 284     ref_array->emplace_back();\r
 285     (*ref_array)[0].erab_id = rand() %15;\r
 286     (*ref_array)[0].drb_id = 150;\r
 287     (*ref_array)[0].pdcp_at_sgnb = 1;\r
 288     (*ref_array)[0].mcg_resources = 1;\r
 289     (*ref_array)[0].scg_resources = 1;\r
 290     (*ref_array)[0].sgnb_pdcp_present = 1;\r
 291     \r
 292     // element sgnb present\r
 293     (*ref_array)[0].sgnb_item.qci = 8;\r
 294     (*ref_array)[0].sgnb_item.priority_level = 8;\r
 295     (*ref_array)[0].sgnb_item.pre_emption_capability = 0;\r
 296     (*ref_array)[0].sgnb_item.pre_emption_vulnerability = 1;\r
 297     (*ref_array)[0].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 298     (*ref_array)[0].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 299     (*ref_array)[0].sgnb_item.gtp_tei = gtp_tei;\r
 300     (*ref_array)[0].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 301     (*ref_array)[0].sgnb_item.rlc_mode = 1;\r
 302     \r
 303     res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 304     REQUIRE(res == false);\r
 305   }\r
 306 \r
 307   SECTION("Invalid Encoding, low buffer"){\r
 308 \r
 309     encode_data.menb_ue_x2ap_id = 12;\r
 310     encode_data.sgnb_ue_x2ap_id = 120;\r
 311 \r
 312     encode_data.bit_rate_max_up = 1000;\r
 313     encode_data.bit_rate_max_dn = 2000;\r
 314 \r
 315     encode_data.encryption_algs = enc_alg;\r
 316     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 317     encode_data.encryption_algs_unused = 0;\r
 318 \r
 319     encode_data.integrity_protection_algs = integrity_alg;\r
 320     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 321     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 322     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 323 \r
 324 \r
 325     encode_data.sgnb_security_key = sgnb_security_key;\r
 326     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 327     encode_data.sgnb_security_key_unused = 0;\r
 328     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 329 \r
 330 \r
 331     encode_data.menb_sgnb_container = mesgnb_container;\r
 332     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 333 \r
 334     encode_data.plmn_identity = plmn;\r
 335     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 336 \r
 337     encode_data.eutran_identifier = eutran;\r
 338     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 339     encode_data.eutran_identifier_unused = 4;\r
 340 \r
 341     REQUIRE(encode_data.eutran_identifier_size*8 - encode_data.eutran_identifier_unused == 28);\r
 342     encode_data.subscriber_profile_id = 34;\r
 343 \r
 344     std::vector<erab_item> * ref_array = encode_data.get_list();\r
 345     ref_array->clear();\r
 346     \r
 347     ref_array->emplace_back();\r
 348     (*ref_array)[0].erab_id = rand() %15;\r
 349     (*ref_array)[0].drb_id = 150;\r
 350     (*ref_array)[0].pdcp_at_sgnb = 1;\r
 351     (*ref_array)[0].mcg_resources = 1;\r
 352     (*ref_array)[0].scg_resources = 1;\r
 353     (*ref_array)[0].sgnb_pdcp_present = 1;\r
 354     \r
 355     // element sgnb present\r
 356     (*ref_array)[0].sgnb_item.qci = 8;\r
 357     (*ref_array)[0].sgnb_item.priority_level = 8;\r
 358     (*ref_array)[0].sgnb_item.pre_emption_capability = 0;\r
 359     (*ref_array)[0].sgnb_item.pre_emption_vulnerability = 1;\r
 360     (*ref_array)[0].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 361     (*ref_array)[0].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 362     (*ref_array)[0].sgnb_item.gtp_tei = gtp_tei;\r
 363     (*ref_array)[0].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 364     (*ref_array)[0].sgnb_item.rlc_mode = 1;\r
 365 \r
 366     buf_size = 10;\r
 367     res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 368     REQUIRE(res == false);\r
 369   }\r
 370   \r
 371   SECTION("Encoding, missing erab"){\r
 372 \r
 373     encode_data.menb_ue_x2ap_id = 12;\r
 374     encode_data.sgnb_ue_x2ap_id = 10;\r
 375 \r
 376     encode_data.bit_rate_max_up = 1000;\r
 377     encode_data.bit_rate_max_dn = 2000;\r
 378 \r
 379     encode_data.encryption_algs = enc_alg;\r
 380     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 381     encode_data.encryption_algs_unused = 0;\r
 382 \r
 383     encode_data.integrity_protection_algs = integrity_alg;\r
 384     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 385     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 386     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 387 \r
 388 \r
 389     encode_data.sgnb_security_key = sgnb_security_key;\r
 390     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 391     encode_data.sgnb_security_key_unused = 0;\r
 392     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 393 \r
 394 \r
 395     encode_data.menb_sgnb_container = mesgnb_container;\r
 396     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 397 \r
 398     encode_data.plmn_identity = plmn;\r
 399     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 400 \r
 401     encode_data.eutran_identifier = eutran;\r
 402     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 403     encode_data.eutran_identifier_unused = 4;\r
 404 \r
 405     encode_data.subscriber_profile_id = 34;\r
 406     res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 407     REQUIRE(res == false);\r
 408   }\r
 409 \r
 410   \r
 411   \r
 412   SECTION("SgnB Addition Response ACK Encoding/decoding with valid data"){\r
 413 \r
 414     encode_data.menb_ue_x2ap_id = 12;\r
 415     encode_data.sgnb_ue_x2ap_id = 10;\r
 416 \r
 417     encode_data.bit_rate_max_up = 1000;\r
 418     encode_data.bit_rate_max_dn = 2000;\r
 419 \r
 420     encode_data.encryption_algs = enc_alg;\r
 421     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 422     encode_data.encryption_algs_unused = 0;\r
 423 \r
 424     encode_data.integrity_protection_algs = integrity_alg;\r
 425     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 426     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 427     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 428 \r
 429 \r
 430     encode_data.sgnb_security_key = sgnb_security_key;\r
 431     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 432     encode_data.sgnb_security_key_unused = 0;\r
 433     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 434 \r
 435 \r
 436     encode_data.menb_sgnb_container = mesgnb_container;\r
 437     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 438 \r
 439     encode_data.plmn_identity = plmn;\r
 440     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 441 \r
 442     encode_data.eutran_identifier = eutran;\r
 443     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 444     encode_data.eutran_identifier_unused = 4;\r
 445 \r
 446     REQUIRE(encode_data.eutran_identifier_size*8 - encode_data.eutran_identifier_unused == 28);\r
 447     encode_data.subscriber_profile_id = 34;\r
 448 \r
 449     std::vector<erab_item> * ref_array = encode_data.get_list();\r
 450     ref_array->clear();\r
 451     \r
 452     int num_erabs = 25;\r
 453     srand(12093021);\r
 454 \r
 455     for(int i = 0; i < num_erabs; i++){\r
 456       \r
 457       ref_array->emplace_back();\r
 458       (*ref_array)[i].erab_id = rand() %15;\r
 459       (*ref_array)[i].drb_id = i%32 + 1;\r
 460       (*ref_array)[i].pdcp_at_sgnb = 1;\r
 461       (*ref_array)[i].mcg_resources = 1;\r
 462       (*ref_array)[i].scg_resources = 1;\r
 463       (*ref_array)[i].sgnb_pdcp_present = 1;\r
 464 \r
 465       // element sgnb present\r
 466       (*ref_array)[i].sgnb_item.qci = 8;\r
 467       (*ref_array)[i].sgnb_item.priority_level = 8;\r
 468       (*ref_array)[i].sgnb_item.pre_emption_capability = 0;\r
 469       (*ref_array)[i].sgnb_item.pre_emption_vulnerability = 1;\r
 470       (*ref_array)[i].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 471       (*ref_array)[i].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 472       (*ref_array)[i].sgnb_item.gtp_tei = gtp_tei;\r
 473       (*ref_array)[i].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 474       (*ref_array)[i].sgnb_item.rlc_mode = 1;\r
 475       \r
 476     }\r
 477 \r
 478     res = resp_out.encode_sgnb_addition_response(buf, &buf_size, encode_data, true);\r
 479     REQUIRE(res == true);\r
 480 \r
 481 \r
 482     // Haven't written get fields for sgnb response yet\r
 483     // int num_tests = 10;\r
 484     // for(int i = 0; i < num_tests; i++){\r
 485     //   decode_data.clear();\r
 486       \r
 487     //   X2_X2AP_PDU_t *x2ap_pdu_obj = 0;\r
 488     //   asn_dec_rval_t rval = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_X2N_X2AP_PDU, (void**)&x2ap_pdu_obj, buf, buf_size);\r
 489     //   REQUIRE(rval.code == RC_OK);\r
 490       \r
 491     //   res = resp_out.get_fields(x2ap_pdu_obj->choice.successfulOutcome, decode_data);\r
 492     //   REQUIRE(res==true);\r
 493       \r
 494     //   REQUIRE(decode_data.sgnb_security_key_size - decode_data.sgnb_security_key_unused == 32);\r
 495     //   REQUIRE(decode_data.eutran_identifier_size*8 - decode_data.eutran_identifier_unused == 28);\r
 496     //   REQUIRE(encode_data.get_list()->size() == decode_data.get_list()->size());\r
 497     //   REQUIRE(encode_data.erab_list[0].erab_id == decode_data.erab_list[0].erab_id);\r
 498     //   REQUIRE(encode_data.erab_list[0].drb_id == decode_data.erab_list[0].drb_id);\r
 499     //   REQUIRE(encode_data.erab_list[0].pdcp_at_sgnb == decode_data.erab_list[0].pdcp_at_sgnb);\r
 500       \r
 501     //   REQUIRE(encode_data.menb_ue_x2ap_id == decode_data.menb_ue_x2ap_id);\r
 502     //   ASN_STRUCT_FREE(asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);\r
 503     // }\r
 504     \r
 505   }\r
 506 \r
 507   SECTION("Encoding response, missing erab"){\r
 508 \r
 509     encode_data.menb_ue_x2ap_id = 12;\r
 510     encode_data.sgnb_ue_x2ap_id = 10;\r
 511 \r
 512     encode_data.bit_rate_max_up = 1000;\r
 513     encode_data.bit_rate_max_dn = 2000;\r
 514 \r
 515     encode_data.encryption_algs = enc_alg;\r
 516     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 517     encode_data.encryption_algs_unused = 0;\r
 518 \r
 519     encode_data.integrity_protection_algs = integrity_alg;\r
 520     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 521     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 522     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 523 \r
 524 \r
 525     encode_data.sgnb_security_key = sgnb_security_key;\r
 526     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 527     encode_data.sgnb_security_key_unused = 0;\r
 528     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 529 \r
 530 \r
 531     encode_data.menb_sgnb_container = mesgnb_container;\r
 532     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 533 \r
 534     encode_data.plmn_identity = plmn;\r
 535     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 536 \r
 537     encode_data.eutran_identifier = eutran;\r
 538     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 539     encode_data.eutran_identifier_unused = 4;\r
 540 \r
 541     encode_data.subscriber_profile_id = 34;\r
 542     res = resp_out.encode_sgnb_addition_response(buf, &buf_size, encode_data, true);\r
 543     REQUIRE(res == false);\r
 544   }\r
 545 \r
 546 \r
 547   //   // Checking Sgnb ACK Encoding\r
 548   //   REQUIRE(response == true);\r
 549   //   res = resp_out.encode_sgnb_addition_response(data_buf, &data_size,decode_data,response);\r
 550   //   REQUIRE(res == true);\r
 551           \r
 552   //   // FILE *pfile;\r
 553   //   // pfile = fopen("sgnb_addition_ack.per", "w");\r
 554   //   // fwrite(data_buf, sizeof(char), data_size, pfile);\r
 555   //   // fclose(pfile);\r
 556   // }\r
 557 \r
 558   SECTION("Response Reject Encoding, valid"){\r
 559     //checking Sgnb Reject Encoding\r
 560     encode_data.menb_ue_x2ap_id = 12;\r
 561     encode_data.sgnb_ue_x2ap_id = 10;\r
 562     encode_data.cause = 1;\r
 563     encode_data.cause_desc = 1;   \r
 564     res = resp_out.encode_sgnb_addition_response(data_buf, &data_size, encode_data, false);\r
 565     std::cout <<"Reason = " << resp_out.get_error() << std::endl;\r
 566     REQUIRE(res==true);\r
 567   }\r
 568   \r
 569   SECTION("Response Reject Encoding, invalid data"){\r
 570     //checking Sgnb Reject Encoding\r
 571     encode_data.menb_ue_x2ap_id = 1200;\r
 572     encode_data.sgnb_ue_x2ap_id = 10;\r
 573     encode_data.cause = 1;\r
 574     encode_data.cause_desc = 1;   \r
 575     res = resp_out.encode_sgnb_addition_response(data_buf, &data_size,decode_data, false);\r
 576     REQUIRE(res==false);\r
 577   }\r
 578 \r
 579         \r
 580 \r
 581 \r
 582 }\r
 583 \r
 584 \r
 585 \r