RIC-E2-TERMINATION/TEST/e2smTest/e2smtest.cpp

   1 /*
   2  * Copyright 2019 AT&T Intellectual Property
   3  * Copyright 2019 Nokia
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /*
  19  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20  * platform project (RICP).
  21  */
  22
  23
  24 //
  25 // Created by adi ENZEL on 6/19/19.
  26 //
  27
  28 #include "../e2sm.h"
  29 #include <mdclog/mdclog.h>
  30
  31 void init_log()
  32 {
  33     mdclog_attr_t *attr;
  34     mdclog_attr_init(&attr);
  35     mdclog_attr_set_ident(attr, "e2smTests");
  36     mdclog_init(attr);
  37     mdclog_attr_destroy(attr);
  38 }
  39
  40 int main(const int argc, char **argv) {
  41     init_log();
  42     //mdclog_level_set(MDCLOG_WARN);
  43     //mdclog_level_set(MDCLOG_INFO);
  44     mdclog_level_set(MDCLOG_DEBUG);
  45
  46     unsigned char plmnidData[3] = {0x33, 0xF4, 0x55};
  47
  48     //mdclog_write(MDCLOG_INFO, "Test PLMN_Identity_t");
  49     PLMN_Identity_t *plmnid = createPLMN_ID(plmnidData);
  50
  51     unsigned char enbData[3] = {0x66, 0x77, 0x88};
  52     ENB_ID_t *enb  = createENB_ID(ENB_ID_PR_macro_eNB_ID, enbData);
  53     enbData[2] = 0x89;
  54     ENB_ID_t *enb1  = createENB_ID(ENB_ID_PR_home_eNB_ID, enbData);
  55     enbData[2] = 0x89;
  56     ENB_ID_t *enb2  = createENB_ID(ENB_ID_PR_long_Macro_eNB_ID, enbData);
  57     enbData[2] = 0x89;
  58     ENB_ID_t *enb3  = createENB_ID(ENB_ID_PR_short_Macro_eNB_ID, enbData);
  59
  60     unsigned char gnbData[3] = {0x99, 0xaa, 0xbb};
  61     GNB_ID_t *gnb = createGnb_id(gnbData, 26);
  62
  63     GlobalENB_ID_t *globalEnb = createGlobalENB_ID(plmnid, enb2);
  64     GlobalGNB_ID_t *globaGnb = createGlobalGNB_ID(plmnid, gnb);
  65
  66     Interface_ID_t *gnbInterfaceId = createInterfaceIDForGnb(globaGnb);
  67
  68     Interface_ID_t *enbInterfaceId = createInterfaceIDForEnb(globalEnb);
  69
  70     InterfaceMessageType_t *initiatingInterface = createInterfaceMessageInitiating(28);
  71
  72     InterfaceMessageType_t *succsesfulInterface = createInterfaceMessageSuccsesful(29);
  73
  74     InterfaceMessageType_t *unSuccsesfulInterface = createInterfaceMessageUnsuccessful(29);
  75
  76     InterfaceProtocolIE_Value_t *intVal = createInterfaceProtocolValueInt(88);
  77
  78     InterfaceProtocolIE_Value_t *enumVal = createInterfaceProtocolValueEnum(2);
  79
  80     InterfaceProtocolIE_Value_t *boolVal = createInterfaceProtocolValueBool(0);
  81
  82     InterfaceProtocolIE_Value_t *bitStringVal = createInterfaceProtocolValueBitString((unsigned char *)"abcd0987", 60);
  83
  84     uint8_t octe[6] = {0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
  85     InterfaceProtocolIE_Value_t *octetsVal = createInterfaceProtocolValueOCTETS(octe);
  86
  87     InterfaceProtocolIE_Item_t *item1 = createInterfaceProtocolIE_Item(10, 0, intVal);
  88     InterfaceProtocolIE_Item_t *item2 = createInterfaceProtocolIE_Item(10, 1, enumVal);
  89     InterfaceProtocolIE_Item_t *item3 = createInterfaceProtocolIE_Item(10, 0, boolVal);
  90     InterfaceProtocolIE_Item_t *item4 = createInterfaceProtocolIE_Item(10, 3, bitStringVal);
  91     InterfaceProtocolIE_Item_t *item5 = createInterfaceProtocolIE_Item(10, 4, octetsVal);
  92
  93     ActionParameter_Item_t *actItem1 = creatActionParameter_Item(17, createActionParameterValue_Int(9));
  94
  95     ActionParameter_Value_t *actP_enum = createActionParameterValue_Enum(5);
  96     ActionParameter_Item_t *actItem2 = creatActionParameter_Item(18, actP_enum);
  97
  98     ActionParameter_Value_t *actP_bool = createActionParameterValue_Bool(0);
  99     ActionParameter_Item_t *actItem3 = creatActionParameter_Item(18, actP_bool);
 100
 101     //ActionParameter_Value_t *actP_bitString = createActionParameterValue_Bit_String((unsigned char *)"ABCDEF", 42);
 102     ActionParameter_Item_t *actItem4 = creatActionParameter_Item(17, createActionParameterValue_Bit_String((unsigned char *)"ABCDEF", 42));
 103
 104     uint8_t octe1[7] = {0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27};
 105     ActionParameter_Value_t *actP_octates = createActionParameterValue_OCTETS(octe1);
 106     ActionParameter_Item_t *actItem5 = creatActionParameter_Item(18, actP_octates);
 107
 108
 109     char print[10] = {'a', 'b', 'C', 'D', 'e', 'f', 'g', 'H', 'I', '\0'};
 110     ActionParameter_Value_t *actP_printable = createActionParameterValue_PRINTS(print);
 111     ActionParameter_Item_t *actItem6 = creatActionParameter_Item(18, actP_printable);
 112
 113     InterfaceProtocolIE_Item_t *interfaceProtocolItemList[] = {item1, item2, item3, item4, item5};
 114     uint8_t buffer[4096];
 115     size_t len;
 116     if ((len = createEventTrigger(gnbInterfaceId,
 117                                        0,
 118                                        initiatingInterface,
 119                                        *interfaceProtocolItemList,
 120                                        5,
 121                                        buffer,
 122                                        4096))  <= 0) {
 123         mdclog_write(MDCLOG_ERR, "returned error from createEventTrigger");
 124     }
 125
 126     ActionParameter_Item_t *actionParamList[] = {actItem1, actItem2, actItem3, actItem4, actItem5, actItem6};
 127     len = createActionDefinition(10034, *actionParamList, 6, buffer, 4096);
 128
 129     len = createE2SM_gNB_X2_indicationHeader(1, enbInterfaceId, nullptr, 0, buffer, 4096);
 130     if (mdclog_level_get() >= MDCLOG_DEBUG) {
 131         mdclog_write(MDCLOG_DEBUG, "Check bad direction in header indication");
 132         len = createE2SM_gNB_X2_indicationHeader(2, enbInterfaceId, nullptr, 0, buffer, 4096);
 133         if (len == (size_t)-1) {
 134             mdclog_write(MDCLOG_DEBUG, "successes call function returned NULL please ignore ERROR log");
 135         }
 136     }
 137
 138     uint8_t msg[] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x0};
 139
 140     int x = 1;
 141     for (int i = 0; i < x; i++) {
 142         len = createE2SM_gNB_X2_indicationMessage(msg, strlen((char *)msg), buffer, 4096);
 143     }
 144
 145     for (int i = 0; i < x; i++) {
 146         len = createE2SM_gNB_X2_callProcessID(8, buffer, 4096);
 147     }
 148
 149     for (int i = 0; i < x; i++) {
 150         len = createE2SM_gNB_X2_controlHeader(enbInterfaceId, 1, buffer, 4096);
 151     }
 152
 153     for (int i = 0; i < x; i++) {
 154         len = createE2SM_gNB_X2_controlHeader(gnbInterfaceId, 1, buffer, 4096);
 155     }
 156
 157     for (int i = 0; i < x; i++) {
 158         len = createE2SM_gNB_X2_controlMessage(msg, strlen((char *)msg), buffer, 4096);
 159     }
 160
 161
 162     return 0;
 163 }