test/unit_test_e2sm.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
  20 #define CATCH_CONFIG_MAIN
  21 #include <catch2/catch.hpp>
  22
  23 #include <cstring>
  24 #include <assert.h>
  25
  26 #include "e2sm.hpp"
  27
  28 TEST_CASE("E2SM Event Trigger Test Cases", "Encoding/decoding"){
  29
  30
  31   unsigned char buf[128];
  32   size_t buf_size = 128;
  33
  34   bool res;
  35   asn_dec_rval_t retval;
  36
  37   e2sm_event_trigger_helper  trigger_data;
  38   e2sm_event_trigger_helper trigger_recv;
  39
  40   e2sm_event_trigger mem_check; // just null declaration to test memory
  41
  42   e2sm_event_trigger e2sm_event_trigger;
  43   E2N_E2SM_gNB_X2_eventTriggerDefinition_t *event; // used for decoding
  44
  45
  46   SECTION("Encoding event trigger, positive and negative cases"){
  47
  48     // fill in data
  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;
  53
  54     trigger_data.procedure_code = 27;
  55     trigger_data.message_type = 0;
  56
  57     //Add multiple interface protocol ie items to cover all test cases ..
  58
  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"));
  64
  65     res = e2sm_event_trigger.encode_event_trigger(&buf[0], &buf_size, trigger_data);
  66     REQUIRE(res == true);
  67
  68     event = 0;
  69     retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, (void**)&(event), &buf[0], buf_size);
  70
  71     REQUIRE(retval.code == RC_OK);
  72     res =  e2sm_event_trigger.get_fields(event, trigger_recv);
  73     REQUIRE(res == true);
  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);
  80
  81     // buffer size too low
  82     buf_size = 2;
  83     res = e2sm_event_trigger.encode_event_trigger(&buf[0], &buf_size, trigger_data);
  84     REQUIRE(res == false);
  85
  86     // invalid constraints ...
  87     trigger_data.interface_direction = 10;
  88     buf_size = 128;
  89     res = e2sm_event_trigger.encode_event_trigger(&buf[0], &buf_size, trigger_data);
  90     REQUIRE(res == false);
  91
  92   }
  93
  94
  95 }
  96
  97
  98 TEST_CASE("E2SM Indication Header", "e2sm_header"){
  99
 100   unsigned char buf_header[128];
 101   unsigned char buf_msg[1024];
 102   size_t header_size = 128;
 103   size_t msg_size = 1024;
 104
 105   std::string test_x2ap_message = "This is X2AP !";
 106
 107   bool res;
 108   asn_dec_rval_t retval;
 109   e2sm_indication e2sm_builder;
 110   e2sm_indication e2sm_receiver;
 111
 112   SECTION("Indication Header encoding/decoding"){
 113     e2sm_header_helper header_tx;
 114
 115     e2sm_header_helper header_re;
 116
 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;
 121
 122     // Encode the message
 123     res = e2sm_builder.encode_indication_header(&buf_header[0], &header_size, header_tx);
 124     REQUIRE(res == true);
 125
 126
 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);
 129
 130     REQUIRE(retval.code == RC_OK);
 131
 132     res = e2sm_receiver.get_header_fields(header, header_re);
 133     REQUIRE(res == true);
 134
 135     REQUIRE(header_re.plmn_id == "the");
 136     ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, header);
 137
 138     // buffer size too low
 139     header_size = 2;
 140     res = e2sm_builder.encode_indication_header(&buf_header[0], &header_size, header_tx);
 141     REQUIRE(res == false);
 142
 143     // invalid constraints ...
 144     header_tx.interface_direction = 10;
 145     header_size = 128;
 146     res = e2sm_builder.encode_indication_header(&buf_header[0], &header_size, header_tx);
 147     REQUIRE(res == false);
 148
 149
 150   }
 151
 152   SECTION("Indication Message encoding/decoding"){
 153
 154     e2sm_message_helper message_tx;
 155     e2sm_message_helper message_re;
 156
 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();
 160
 161
 162     res = e2sm_builder.encode_indication_message(&buf_msg[0], &msg_size, message_tx);
 163     REQUIRE(res == true);
 164
 165     E2N_E2SM_gNB_X2_indicationMessage_t *message = 0; // used for decoding
 166
 167     retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, (void**)&(message), &buf_msg[0], msg_size);
 168
 169     REQUIRE(retval.code == RC_OK);
 170     res = e2sm_receiver.get_message_fields(message, message_re);
 171     REQUIRE(res == true);
 172
 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);
 176   }
 177
 178
 179 }
 180
 181
 182
 183 TEST_CASE("E2SM Encoding/Decoding", "Control"){
 184
 185   unsigned char buf_header[128];
 186   unsigned char buf_msg[1024];
 187   size_t header_size = 128;
 188   size_t msg_size = 1024;
 189
 190   e2sm_control e2sm_builder;
 191   e2sm_header_helper header_tx;
 192   e2sm_message_helper message_tx;
 193
 194
 195   e2sm_control e2sm_receiver;
 196   e2sm_header_helper header_re;
 197   e2sm_message_helper message_re;
 198
 199
 200   bool res;
 201   asn_dec_rval_t retval;
 202
 203   E2N_E2SM_gNB_X2_controlHeader_t *header; // used for decoding
 204   E2N_E2SM_gNB_X2_controlMessage_t *message; // used for decoding
 205
 206   SECTION("Control encoding/decoding header"){
 207
 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;
 212
 213
 214     res = e2sm_builder.encode_control_header(&buf_header[0], &header_size, header_tx);
 215     REQUIRE(res == true);
 216
 217     // =================================
 218     // Decode the message
 219     header = 0;
 220     retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_controlHeader, (void**)&(header), &buf_header[0], header_size);
 221
 222     REQUIRE(retval.code == RC_OK);
 223
 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);
 228
 229     // free the struct since we have already extracted all references
 230     ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_controlHeader, header);
 231   }
 232
 233   SECTION("Control message encoding/decoding"){
 234
 235     std::string test_x2ap_message = "This is X2AP !";
 236
 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();
 240
 241     res = e2sm_builder.encode_control_message(&buf_msg[0], &msg_size, message_tx);
 242     REQUIRE(res == true);
 243
 244
 245     message = 0;
 246     retval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_controlMessage, (void**)&(message), &buf_msg[0], msg_size);
 247
 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);
 254   }
 255
 256 }