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         ASN_STRUCT_FREE(asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);\r
 170       }\r
 171       \r
 172     }\r
 173 \r
 174 \r
 175     // pdcp not present\r
 176     for(int num_erabs = 1; num_erabs < max_erabs; num_erabs++){\r
 177 \r
 178       ref_array->clear();\r
 179       \r
 180       for(int i = 0; i < num_erabs; i++){\r
 181       \r
 182         ref_array->emplace_back();\r
 183         (*ref_array)[i].erab_id = rand() %15;\r
 184         (*ref_array)[i].drb_id = i%32 + 1;\r
 185         (*ref_array)[i].pdcp_at_sgnb = 1;\r
 186         (*ref_array)[i].mcg_resources = 1;\r
 187         (*ref_array)[i].scg_resources = 1;\r
 188         (*ref_array)[i].sgnb_pdcp_present = 2;\r
 189         \r
 190         // element sgnb present\r
 191         (*ref_array)[i].sgnb_item.qci = 8;\r
 192         (*ref_array)[i].sgnb_item.priority_level = 8;\r
 193         (*ref_array)[i].sgnb_item.pre_emption_capability = 0;\r
 194         (*ref_array)[i].sgnb_item.pre_emption_vulnerability = 1;\r
 195         (*ref_array)[i].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 196         (*ref_array)[i].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 197         (*ref_array)[i].sgnb_item.gtp_tei = gtp_tei;\r
 198         (*ref_array)[i].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 199         (*ref_array)[i].sgnb_item.rlc_mode = 1;\r
 200         \r
 201       }\r
 202       \r
 203       buf_size = BUFFER_SIZE;\r
 204       res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 205       REQUIRE(res == true);\r
 206       \r
 207       // std::string out_file = std::string("X2AP-PDU-SgNBAdditionRequest-NoPDCP-NumErabs-") + std::to_string(num_erabs) + std::string(".per");\r
 208       // FILE *pfile = fopen(out_file.c_str(), "w");\r
 209       // fwrite(buf, sizeof(char), buf_size, pfile);\r
 210       // fclose(pfile);\r
 211       \r
 212       \r
 213       int num_tests = 10;\r
 214       for(int i = 0; i < num_tests; i++){\r
 215         decode_data.clear();\r
 216         \r
 217         X2N_X2AP_PDU_t *x2ap_pdu_obj = 0;\r
 218         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
 219         REQUIRE(rval.code == RC_OK);\r
 220         \r
 221         res = decode_test.get_fields(x2ap_pdu_obj->choice.initiatingMessage, decode_data);\r
 222         REQUIRE(res==true);\r
 223         \r
 224         REQUIRE(decode_data.sgnb_security_key_size - decode_data.sgnb_security_key_unused == 32);\r
 225         REQUIRE(decode_data.eutran_identifier_size*8 - decode_data.eutran_identifier_unused == 28);\r
 226         REQUIRE(encode_data.get_list()->size() == decode_data.get_list()->size());\r
 227         REQUIRE(encode_data.erab_list[0].erab_id == decode_data.erab_list[0].erab_id);\r
 228         REQUIRE(encode_data.erab_list[0].drb_id == decode_data.erab_list[0].drb_id);\r
 229         REQUIRE(encode_data.erab_list[0].pdcp_at_sgnb == decode_data.erab_list[0].pdcp_at_sgnb);\r
 230         \r
 231         REQUIRE(encode_data.menb_ue_x2ap_id == decode_data.menb_ue_x2ap_id);\r
 232         REQUIRE(encode_data.bit_rate_max_up == decode_data.bit_rate_max_up);\r
 233         REQUIRE(encode_data.bit_rate_max_dn == decode_data.bit_rate_max_dn);\r
 234         ASN_STRUCT_FREE(asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);\r
 235       }\r
 236       \r
 237     }\r
 238     \r
 239   }\r
 240   \r
 241   SECTION("Encoding, invalid erab"){\r
 242 \r
 243     encode_data.menb_ue_x2ap_id = 12;\r
 244     encode_data.sgnb_ue_x2ap_id = 120;\r
 245 \r
 246     encode_data.bit_rate_max_up = 1000;\r
 247     encode_data.bit_rate_max_dn = 2000;\r
 248 \r
 249     encode_data.encryption_algs = enc_alg;\r
 250     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 251     encode_data.encryption_algs_unused = 0;\r
 252 \r
 253     encode_data.integrity_protection_algs = integrity_alg;\r
 254     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 255     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 256     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 257 \r
 258 \r
 259     encode_data.sgnb_security_key = sgnb_security_key;\r
 260     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 261     encode_data.sgnb_security_key_unused = 0;\r
 262     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 263 \r
 264 \r
 265     encode_data.menb_sgnb_container = mesgnb_container;\r
 266     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 267 \r
 268     encode_data.plmn_identity = plmn;\r
 269     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 270 \r
 271     encode_data.eutran_identifier = eutran;\r
 272     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 273     encode_data.eutran_identifier_unused = 4;\r
 274 \r
 275     REQUIRE(encode_data.eutran_identifier_size*8 - encode_data.eutran_identifier_unused == 28);\r
 276     encode_data.subscriber_profile_id = 34;\r
 277 \r
 278     std::vector<erab_item> * ref_array = encode_data.get_list();\r
 279     ref_array->clear();\r
 280     \r
 281     ref_array->emplace_back();\r
 282     (*ref_array)[0].erab_id = rand() %15;\r
 283     (*ref_array)[0].drb_id = 150;\r
 284     (*ref_array)[0].pdcp_at_sgnb = 1;\r
 285     (*ref_array)[0].mcg_resources = 1;\r
 286     (*ref_array)[0].scg_resources = 1;\r
 287     (*ref_array)[0].sgnb_pdcp_present = 1;\r
 288     \r
 289     // element sgnb present\r
 290     (*ref_array)[0].sgnb_item.qci = 8;\r
 291     (*ref_array)[0].sgnb_item.priority_level = 8;\r
 292     (*ref_array)[0].sgnb_item.pre_emption_capability = 0;\r
 293     (*ref_array)[0].sgnb_item.pre_emption_vulnerability = 1;\r
 294     (*ref_array)[0].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 295     (*ref_array)[0].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 296     (*ref_array)[0].sgnb_item.gtp_tei = gtp_tei;\r
 297     (*ref_array)[0].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 298     (*ref_array)[0].sgnb_item.rlc_mode = 1;\r
 299     \r
 300     res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 301     REQUIRE(res == false);\r
 302   }\r
 303 \r
 304   SECTION("Invalid Encoding, low buffer"){\r
 305 \r
 306     encode_data.menb_ue_x2ap_id = 12;\r
 307     encode_data.sgnb_ue_x2ap_id = 120;\r
 308 \r
 309     encode_data.bit_rate_max_up = 1000;\r
 310     encode_data.bit_rate_max_dn = 2000;\r
 311 \r
 312     encode_data.encryption_algs = enc_alg;\r
 313     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 314     encode_data.encryption_algs_unused = 0;\r
 315 \r
 316     encode_data.integrity_protection_algs = integrity_alg;\r
 317     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 318     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 319     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 320 \r
 321 \r
 322     encode_data.sgnb_security_key = sgnb_security_key;\r
 323     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 324     encode_data.sgnb_security_key_unused = 0;\r
 325     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 326 \r
 327 \r
 328     encode_data.menb_sgnb_container = mesgnb_container;\r
 329     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 330 \r
 331     encode_data.plmn_identity = plmn;\r
 332     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 333 \r
 334     encode_data.eutran_identifier = eutran;\r
 335     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 336     encode_data.eutran_identifier_unused = 4;\r
 337 \r
 338     REQUIRE(encode_data.eutran_identifier_size*8 - encode_data.eutran_identifier_unused == 28);\r
 339     encode_data.subscriber_profile_id = 34;\r
 340 \r
 341     std::vector<erab_item> * ref_array = encode_data.get_list();\r
 342     ref_array->clear();\r
 343     \r
 344     ref_array->emplace_back();\r
 345     (*ref_array)[0].erab_id = rand() %15;\r
 346     (*ref_array)[0].drb_id = 150;\r
 347     (*ref_array)[0].pdcp_at_sgnb = 1;\r
 348     (*ref_array)[0].mcg_resources = 1;\r
 349     (*ref_array)[0].scg_resources = 1;\r
 350     (*ref_array)[0].sgnb_pdcp_present = 1;\r
 351     \r
 352     // element sgnb present\r
 353     (*ref_array)[0].sgnb_item.qci = 8;\r
 354     (*ref_array)[0].sgnb_item.priority_level = 8;\r
 355     (*ref_array)[0].sgnb_item.pre_emption_capability = 0;\r
 356     (*ref_array)[0].sgnb_item.pre_emption_vulnerability = 1;\r
 357     (*ref_array)[0].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 358     (*ref_array)[0].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 359     (*ref_array)[0].sgnb_item.gtp_tei = gtp_tei;\r
 360     (*ref_array)[0].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 361     (*ref_array)[0].sgnb_item.rlc_mode = 1;\r
 362 \r
 363     buf_size = 10;\r
 364     res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 365     REQUIRE(res == false);\r
 366   }\r
 367   \r
 368   SECTION("Encoding, missing erab"){\r
 369 \r
 370     encode_data.menb_ue_x2ap_id = 12;\r
 371     encode_data.sgnb_ue_x2ap_id = 10;\r
 372 \r
 373     encode_data.bit_rate_max_up = 1000;\r
 374     encode_data.bit_rate_max_dn = 2000;\r
 375 \r
 376     encode_data.encryption_algs = enc_alg;\r
 377     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 378     encode_data.encryption_algs_unused = 0;\r
 379 \r
 380     encode_data.integrity_protection_algs = integrity_alg;\r
 381     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 382     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 383     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 384 \r
 385 \r
 386     encode_data.sgnb_security_key = sgnb_security_key;\r
 387     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 388     encode_data.sgnb_security_key_unused = 0;\r
 389     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 390 \r
 391 \r
 392     encode_data.menb_sgnb_container = mesgnb_container;\r
 393     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 394 \r
 395     encode_data.plmn_identity = plmn;\r
 396     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 397 \r
 398     encode_data.eutran_identifier = eutran;\r
 399     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 400     encode_data.eutran_identifier_unused = 4;\r
 401 \r
 402     encode_data.subscriber_profile_id = 34;\r
 403     res = encode_test.encode_sgnb_addition_request(buf, &buf_size, encode_data);\r
 404     REQUIRE(res == false);\r
 405   }\r
 406 \r
 407   \r
 408   \r
 409   SECTION("SgnB Addition Response ACK Encoding/decoding with valid data"){\r
 410 \r
 411     encode_data.menb_ue_x2ap_id = 12;\r
 412     encode_data.sgnb_ue_x2ap_id = 10;\r
 413 \r
 414     encode_data.bit_rate_max_up = 1000;\r
 415     encode_data.bit_rate_max_dn = 2000;\r
 416 \r
 417     encode_data.encryption_algs = enc_alg;\r
 418     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 419     encode_data.encryption_algs_unused = 0;\r
 420 \r
 421     encode_data.integrity_protection_algs = integrity_alg;\r
 422     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 423     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 424     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 425 \r
 426 \r
 427     encode_data.sgnb_security_key = sgnb_security_key;\r
 428     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 429     encode_data.sgnb_security_key_unused = 0;\r
 430     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 431 \r
 432 \r
 433     encode_data.menb_sgnb_container = mesgnb_container;\r
 434     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 435 \r
 436     encode_data.plmn_identity = plmn;\r
 437     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 438 \r
 439     encode_data.eutran_identifier = eutran;\r
 440     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 441     encode_data.eutran_identifier_unused = 4;\r
 442 \r
 443     REQUIRE(encode_data.eutran_identifier_size*8 - encode_data.eutran_identifier_unused == 28);\r
 444     encode_data.subscriber_profile_id = 34;\r
 445 \r
 446     std::vector<erab_item> * ref_array = encode_data.get_list();\r
 447     ref_array->clear();\r
 448     \r
 449     int num_erabs = 25;\r
 450     srand(12093021);\r
 451 \r
 452     for(int i = 0; i < num_erabs; i++){\r
 453       \r
 454       ref_array->emplace_back();\r
 455       (*ref_array)[i].erab_id = rand() %15;\r
 456       (*ref_array)[i].drb_id = i%32 + 1;\r
 457       (*ref_array)[i].pdcp_at_sgnb = 1;\r
 458       (*ref_array)[i].mcg_resources = 1;\r
 459       (*ref_array)[i].scg_resources = 1;\r
 460       (*ref_array)[i].sgnb_pdcp_present = 1;\r
 461 \r
 462       // element sgnb present\r
 463       (*ref_array)[i].sgnb_item.qci = 8;\r
 464       (*ref_array)[i].sgnb_item.priority_level = 8;\r
 465       (*ref_array)[i].sgnb_item.pre_emption_capability = 0;\r
 466       (*ref_array)[i].sgnb_item.pre_emption_vulnerability = 1;\r
 467       (*ref_array)[i].sgnb_item.transport_layer_addr = transport_layer_addr;\r
 468       (*ref_array)[i].sgnb_item.transport_layer_addr_size = strlen((char *)transport_layer_addr);\r
 469       (*ref_array)[i].sgnb_item.gtp_tei = gtp_tei;\r
 470       (*ref_array)[i].sgnb_item.gtp_tei_size = strlen((char *)gtp_tei);\r
 471       (*ref_array)[i].sgnb_item.rlc_mode = 1;\r
 472       \r
 473     }\r
 474 \r
 475     res = resp_out.encode_sgnb_addition_response(buf, &buf_size, encode_data, true);\r
 476     REQUIRE(res == true);\r
 477 \r
 478 \r
 479     // Haven't written get fields for sgnb response yet\r
 480     // int num_tests = 10;\r
 481     // for(int i = 0; i < num_tests; i++){\r
 482     //   decode_data.clear();\r
 483       \r
 484     //   X2_X2AP_PDU_t *x2ap_pdu_obj = 0;\r
 485     //   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
 486     //   REQUIRE(rval.code == RC_OK);\r
 487       \r
 488     //   res = resp_out.get_fields(x2ap_pdu_obj->choice.successfulOutcome, decode_data);\r
 489     //   REQUIRE(res==true);\r
 490       \r
 491     //   REQUIRE(decode_data.sgnb_security_key_size - decode_data.sgnb_security_key_unused == 32);\r
 492     //   REQUIRE(decode_data.eutran_identifier_size*8 - decode_data.eutran_identifier_unused == 28);\r
 493     //   REQUIRE(encode_data.get_list()->size() == decode_data.get_list()->size());\r
 494     //   REQUIRE(encode_data.erab_list[0].erab_id == decode_data.erab_list[0].erab_id);\r
 495     //   REQUIRE(encode_data.erab_list[0].drb_id == decode_data.erab_list[0].drb_id);\r
 496     //   REQUIRE(encode_data.erab_list[0].pdcp_at_sgnb == decode_data.erab_list[0].pdcp_at_sgnb);\r
 497       \r
 498     //   REQUIRE(encode_data.menb_ue_x2ap_id == decode_data.menb_ue_x2ap_id);\r
 499     //   ASN_STRUCT_FREE(asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);\r
 500     // }\r
 501     \r
 502   }\r
 503 \r
 504   SECTION("Encoding response, missing erab"){\r
 505 \r
 506     encode_data.menb_ue_x2ap_id = 12;\r
 507     encode_data.sgnb_ue_x2ap_id = 10;\r
 508 \r
 509     encode_data.bit_rate_max_up = 1000;\r
 510     encode_data.bit_rate_max_dn = 2000;\r
 511 \r
 512     encode_data.encryption_algs = enc_alg;\r
 513     encode_data.encryption_algs_size = strlen((char *)enc_alg);\r
 514     encode_data.encryption_algs_unused = 0;\r
 515 \r
 516     encode_data.integrity_protection_algs = integrity_alg;\r
 517     encode_data.integrity_protection_algs_size = strlen((char *)integrity_alg);\r
 518     encode_data.integrity_protection_algs_unused = encode_data.integrity_protection_algs_size/8;\r
 519     REQUIRE(encode_data.integrity_protection_algs_size - encode_data.integrity_protection_algs_unused == 2);\r
 520 \r
 521 \r
 522     encode_data.sgnb_security_key = sgnb_security_key;\r
 523     encode_data.sgnb_security_key_size = strlen((char *)sgnb_security_key);\r
 524     encode_data.sgnb_security_key_unused = 0;\r
 525     REQUIRE(encode_data.sgnb_security_key_size - encode_data.sgnb_security_key_unused == 32);\r
 526 \r
 527 \r
 528     encode_data.menb_sgnb_container = mesgnb_container;\r
 529     encode_data.menb_sgnb_container_size = strlen((char *)mesgnb_container);\r
 530 \r
 531     encode_data.plmn_identity = plmn;\r
 532     encode_data.plmn_identity_size = strlen((char *)plmn);\r
 533 \r
 534     encode_data.eutran_identifier = eutran;\r
 535     encode_data.eutran_identifier_size = strlen((char *)eutran);\r
 536     encode_data.eutran_identifier_unused = 4;\r
 537 \r
 538     encode_data.subscriber_profile_id = 34;\r
 539     res = resp_out.encode_sgnb_addition_response(buf, &buf_size, encode_data, true);\r
 540     REQUIRE(res == false);\r
 541   }\r
 542 \r
 543 \r
 544   //   // Checking Sgnb ACK Encoding\r
 545   //   REQUIRE(response == true);\r
 546   //   res = resp_out.encode_sgnb_addition_response(data_buf, &data_size,decode_data,response);\r
 547   //   REQUIRE(res == true);\r
 548           \r
 549   //   // FILE *pfile;\r
 550   //   // pfile = fopen("sgnb_addition_ack.per", "w");\r
 551   //   // fwrite(data_buf, sizeof(char), data_size, pfile);\r
 552   //   // fclose(pfile);\r
 553   // }\r
 554 \r
 555   SECTION("Response Reject Encoding, valid"){\r
 556     //checking Sgnb Reject Encoding\r
 557     encode_data.menb_ue_x2ap_id = 12;\r
 558     encode_data.sgnb_ue_x2ap_id = 10;\r
 559     encode_data.cause = 1;\r
 560     encode_data.cause_desc = 1;   \r
 561     res = resp_out.encode_sgnb_addition_response(data_buf, &data_size, encode_data, false);\r
 562     std::cout <<"Reason = " << resp_out.get_error() << std::endl;\r
 563     REQUIRE(res==true);\r
 564   }\r
 565   \r
 566   SECTION("Response Reject Encoding, invalid data"){\r
 567     //checking Sgnb Reject Encoding\r
 568     encode_data.menb_ue_x2ap_id = 1200;\r
 569     encode_data.sgnb_ue_x2ap_id = 10;\r
 570     encode_data.cause = 1;\r
 571     encode_data.cause_desc = 1;   \r
 572     res = resp_out.encode_sgnb_addition_response(data_buf, &data_size,decode_data, false);\r
 573     REQUIRE(res==false);\r
 574   }\r
 575 \r
 576         \r
 577 \r
 578 \r
 579 }\r
 580 \r
 581 \r
 582 \r