// This C++ source file was generated by the TTCN-3 compiler
// of the TTCN-3 Test Executor version 11.1.0
// The generation of user and time information were disabled by the -D flag.

// Copyright (c) 2000-2025 Ericsson Telecom AB

// Do not edit this file unless you know what you are doing.

/* Including header files */

#include "HNBGW_Tests.hh"

namespace HNBGW__Tests {

/* Literal string constants */

const unsigned char hs_1_nibbles[] = { 0, 1 },
hs_7_nibbles[] = { 0, 1, 1, 0, 0, 0, 0, 2 },
hs_8_nibbles[] = { 0, 1, 1, 0, 0, 0, 0, 3 },
hs_5_nibbles[] = { 0, 1, 1, 0, 0, 0, 33, 3 },
hs_6_nibbles[] = { 0, 1, 1, 0, 0, 0, 33, 4 },
hs_0_nibbles[] = { 0, 31, 1 },
hs_2_nibbles[] = { 16 },
hs_4_nibbles[] = { 153 },
hs_3_nibbles[] = { 153, 9 };
extern const HEXSTRING hs_1(3, hs_1_nibbles),
hs_7(15, hs_7_nibbles),
hs_8(15, hs_8_nibbles),
hs_5(15, hs_5_nibbles),
hs_6(15, hs_6_nibbles),
hs_0(6, hs_0_nibbles),
hs_2(2, hs_2_nibbles),
hs_4(2, hs_4_nibbles),
hs_3(3, hs_3_nibbles);
const unsigned char os_0_octets[] = { 0, 241, 16 },
os_3_octets[] = { 23 },
os_1_octets[] = { 35, 66 },
os_2_octets[] = { 42, 42 },
os_4_octets[] = { 153, 249, 153 };
extern const OCTETSTRING os_0(3, os_0_octets),
os_3(1, os_3_octets),
os_1(2, os_1_octets),
os_2(2, os_2_octets),
os_4(3, os_4_octets);
extern const CHARSTRING cs_3(12, "\aosmocom\003org"),
cs_20('\n'),
cs_21(' '),
cs_50(10, " data_len="),
cs_52(25, " expect_separate_sccp_cr="),
cs_51(19, " max_optional_data="),
cs_29(12, " ranap reset"),
cs_69(16, " rate counters: "),
cs_33('-'),
cs_15(4, "-Iuh"),
cs_10(5, "-MGCP"),
cs_14(5, "-PFCP"),
cs_16(4, "-RUA"),
cs_38('.'),
cs_80(6, "0.42.4"),
cs_0(9, "127.0.0.1"),
cs_2(9, "127.0.0.2"),
cs_59(9, "127.3.2.1"),
cs_82(26, "Apply SCCP address changes"),
cs_37('C'),
cs_78(38, "Changing SCCP address, don't apply yet"),
cs_26(5, "HNBGW"),
cs_25(11, "HNBGW_Test."),
cs_13(16, "HNBGW_Tests.ttcn"),
cs_34('L'),
cs_5(6, "Mapped"),
cs_7(7, "OsmoSTP"),
cs_35('R'),
cs_88(27, "Restarting HNBGW ASP in STP"),
cs_36('S'),
cs_86(30, "Shutting down HNBGW ASP in STP"),
cs_46(27, "TC_hnb_disconnected_timeout"),
cs_49(37, "TEST PART TC_sccp_cr_limit ps_domain="),
cs_39(10, "TTCN3-HNB-"),
cs_1(6, "TTCN3."),
cs_62(37, "Timeout waiting for PFCP Sess Del Req"),
cs_27(9, "VirtHNBGW"),
cs_22(12, "allow-attach"),
cs_77(10, "apply sccp"),
cs_31(12, "asn1_context"),
cs_8(27, "asp hnbgw0-0 2906 2905 m3ua"),
cs_54('c'),
cs_71(23, "cnpool roundrobin next "),
cs_66(25, "cnpool:subscr:attach_lost"),
cs_64(19, "cnpool:subscr:known"),
cs_63(17, "cnpool:subscr:new"),
cs_67(19, "cnpool:subscr:paged"),
cs_65(22, "cnpool:subscr:reattach"),
cs_85(9, "connected"),
cs_73(19, "connecting cnlink 1"),
cs_9(14, "cs7 instance 0"),
cs_72(18, "disconnecting msc0"),
cs_6(6, "enable"),
cs_44(3, "end"),
cs_24(4, "exit"),
cs_4(3, "foo"),
cs_12('g'),
cs_42(3, "hnb"),
cs_32(4, "hnb."),
cs_43(5, "hnbgw"),
cs_68(8, "initial "),
cs_41(15, "iuh:established"),
cs_19(3, "msc"),
cs_28(4, "msc "),
cs_81(5, "msc 0"),
cs_79(7, "msc-foo"),
cs_83(6, "msc.0."),
cs_23(15, "no allow-attach"),
cs_89(11, "no shutdown"),
cs_70(4, "omit"),
cs_75(11, "point-code "),
cs_55(20, "ranap.cs.rab_act.cnf"),
cs_56(21, "ranap.cs.rab_act.fail"),
cs_53(20, "ranap.cs.rab_act.req"),
cs_58(29, "ranap.cs.rab_rel.req.abnormal"),
cs_57(27, "ranap.cs.rab_rel.req.normal"),
cs_61(29, "ranap.ps.rab_rel.req.abnormal"),
cs_60(27, "ranap.ps.rab_rel.req.normal"),
cs_76(12, "remote-addr "),
cs_48(23, "sccp max-optional-data "),
cs_74(13, "sccp-address "),
cs_18(4, "sgsn"),
cs_30(5, "sgsn "),
cs_84(7, "sgsn.0."),
cs_17(19, "show running-config"),
cs_87(8, "shutdown"),
cs_47(8, "standard"),
cs_40(18, "struct hnb_context"),
cs_45(17, "timer hnbgw X35 5"),
cs_11(21, "upf.0.pfcp_associated");
const unsigned char module_checksum[] = { 0x77, 0x13, 0x6b, 0xda, 0x67, 0xd0, 0x59, 0xbd, 0xdd, 0xfd, 0x53, 0x35, 0xe2, 0xbe, 0x33, 0x12 };

/* Global variable definitions */

INTEGER const_NUM__MSC;
const INTEGER& NUM__MSC = const_NUM__MSC;
INTEGER const_NUM__SGSN;
const INTEGER& NUM__SGSN = const_NUM__SGSN;
INTEGER const_FIRST__MSC__IDX;
const INTEGER& FIRST__MSC__IDX = const_FIRST__MSC__IDX;
INTEGER const_FIRST__SGSN__IDX;
const INTEGER& FIRST__SGSN__IDX = const_FIRST__SGSN__IDX;
INTEGER const_f__cn__idx_cn__nr_defval;
const INTEGER& f__cn__idx_cn__nr_defval = const_f__cn__idx_cn__nr_defval;
CHARSTRING modulepar_mp__hnodeb__ip;
const CHARSTRING& mp__hnodeb__ip = modulepar_mp__hnodeb__ip;
INTEGER modulepar_mp__hnodeb__port;
const INTEGER& mp__hnodeb__port = modulepar_mp__hnodeb__port;
CHARSTRING modulepar_mp__hnbgw__ip;
const CHARSTRING& mp__hnbgw__ip = modulepar_mp__hnbgw__ip;
INTEGER modulepar_mp__hnbgw__iuh__port;
const INTEGER& mp__hnbgw__iuh__port = modulepar_mp__hnbgw__iuh__port;
INTEGER modulepar_mp__hnbgw__ctrl__port;
const INTEGER& mp__hnbgw__ctrl__port = modulepar_mp__hnbgw__ctrl__port;
CHARSTRING modulepar_mp__local__statsd__ip;
const CHARSTRING& mp__local__statsd__ip = modulepar_mp__local__statsd__ip;
INTEGER modulepar_mp__local__statsd__port;
const INTEGER& mp__local__statsd__port = modulepar_mp__local__statsd__port;
CHARSTRING modulepar_mp__statsd__prefix;
const CHARSTRING& mp__statsd__prefix = modulepar_mp__statsd__prefix;
CHARSTRING modulepar_mp__mgw__ip;
const CHARSTRING& mp__mgw__ip = modulepar_mp__mgw__ip;
INTEGER modulepar_mp__mgw__port;
const INTEGER& mp__mgw__port = modulepar_mp__mgw__port;
RAN__Adapter::RAN__Configurations modulepar_mp__cn__cfg;
const RAN__Adapter::RAN__Configurations& mp__cn__cfg = modulepar_mp__cn__cfg;
BOOLEAN modulepar_mp__enable__pfcp__tests;
const BOOLEAN& mp__enable__pfcp__tests = modulepar_mp__enable__pfcp__tests;
CHARSTRING modulepar_mp__pfcp__ip__local;
const CHARSTRING& mp__pfcp__ip__local = modulepar_mp__pfcp__ip__local;
CHARSTRING modulepar_mp__pfcp__ip__remote;
const CHARSTRING& mp__pfcp__ip__remote = modulepar_mp__pfcp__ip__remote;
CHARSTRING modulepar_mp__pfcp__upf__node__id;
const CHARSTRING& mp__pfcp__upf__node__id = modulepar_mp__pfcp__upf__node__id;
BOOLEAN modulepar_mp__validate__talloc__asn1;
const BOOLEAN& mp__validate__talloc__asn1 = modulepar_mp__validate__talloc__asn1;
INTEGER modulepar_mp__hnbgw__timer__x31;
const INTEGER& mp__hnbgw__timer__x31 = modulepar_mp__hnbgw__timer__x31;
RAN__Emulation::RanOps const_MSC__RanOps;
const RAN__Emulation::RanOps& MSC__RanOps = const_MSC__RanOps;
INTEGER const_NUM__HNB;
const INTEGER& NUM__HNB = const_NUM__HNB;
const TTCN_Typedescriptor_t& test__CT_descr_ = COMPONENT_descr_;
BOOLEAN test__CT_component_g__initialized;
VALUE_ARRAY<RAN__Adapter::RAN__Adapter, 8, 0> test__CT_component_g__cn;
VALUE_ARRAY<ConnHdlr::HnbConfig, 2, 0> test__CT_component_g__hnb__cfg;
VALUE_ARRAY<COMPONENT, 2, 0> test__CT_component_vc__Iuh;
VALUE_ARRAY<COMPONENT, 2, 0> test__CT_component_vc__RUA;
PORT_ARRAY<Iuh__Emulation::HNBAP__PT, 2, 0> test__CT_component_HNBAP;
INTEGER test__CT_component_g__num__hnbs;
COMPONENT test__CT_component_vc__MGCP;
TELNETasp__PortType::TELNETasp__PT test__CT_component_HNBGWVTY("HNBGWVTY");
TELNETasp__PortType::TELNETasp__PT test__CT_component_STPVTY("STPVTY");
COMPONENT test__CT_component_vc__STATSD;
COMPONENT test__CT_component_vc__PFCP;
TIMER test__CT_component_T__guard("T_guard", 4.5e1);
FLOAT test__CT_component_g__statd__timeout;
CHARSTRING test__CT_component_g__ctr__cn__node__name;
Osmocom__CTRL__Functions::CounterNameValsList test__CT_component_g__ctr__cn;
Osmocom__CTRL__Functions::CounterNameValsList test__CT_component_g__ctr__hnb;
RAN__Emulation::RanOps test__CT_component_g__ran__ops;
COMPONENT test__CT_component_vc__mutex__disp;
CHARSTRING const_f__init__vty_id_defval;
const CHARSTRING& f__init__vty_id_defval = const_f__init__vty_id_defval;
BOOLEAN const_f__pfcp__wait__assoc__setup__req_fail__timeout_defval;
const BOOLEAN& f__pfcp__wait__assoc__setup__req_fail__timeout_defval = const_f__pfcp__wait__assoc__setup__req_fail__timeout_defval;
// No XER for BooleanList
const TTCN_Typedescriptor_t BooleanList_descr_ = { "@HNBGW_Tests.BooleanList", NULL, NULL, NULL, NULL, NULL, NULL, NULL, &BOOLEAN_descr_, TTCN_Typedescriptor_t::DONTCARE };
const XERdescriptor_t       BooleanList_0_xer_ = { {"BOOLEAN>\n", "BOOLEAN>\n"}, {9, 9}, 0 |FORM_UNQUALIFIED, WHITESPACE_PRESERVE,  NULL, &module_object, -1, 0, NULL, NULL, -1, XSD_NONE };
const int BooleanList_0_oer_ext_arr_[0] = {};
const int BooleanList_0_oer_p_[0] = {};
const TTCN_OERdescriptor_t BooleanList_0_oer_ = { -1, TRUE, -1, FALSE, 0, 0, BooleanList_0_oer_ext_arr_, 0, BooleanList_0_oer_p_};
const TTCN_Typedescriptor_t BooleanList_0_descr_ = { "@HNBGW_Tests.BooleanList.BOOLEAN", &BOOLEAN_ber_, &BOOLEAN_raw_, &BOOLEAN_text_, &BooleanList_0_xer_, &BOOLEAN_json_, &BooleanList_0_oer_, NULL, NULL, TTCN_Typedescriptor_t::DONTCARE };
CHARSTRING const_f__init_id_defval;
const CHARSTRING& f__init_id_defval = const_f__init_id_defval;
FLOAT const_f__init_guard__timeout_defval;
const FLOAT& f__init_guard__timeout_defval = const_f__init_guard__timeout_defval;
INTEGER const_f__init_nr__msc_defval;
const INTEGER& f__init_nr__msc_defval = const_f__init_nr__msc_defval;
INTEGER const_f__init_nr__sgsn_defval;
const INTEGER& f__init_nr__sgsn_defval = const_f__init_nr__sgsn_defval;
BOOLEAN const_f__init_start__hnb_defval;
const BOOLEAN& f__init_start__hnb_defval = const_f__init_start__hnb_defval;
BOOLEAN const_f__TestHdlrParams_ps__domain_defval;
const BOOLEAN& f__TestHdlrParams_ps__domain_defval = const_f__TestHdlrParams_ps__domain_defval;
BOOLEAN const_f__TestHdlrParams_expect__separate__sccp__cr_defval;
const BOOLEAN& f__TestHdlrParams_expect__separate__sccp__cr_defval = const_f__TestHdlrParams_expect__separate__sccp__cr_defval;
INTEGER const_f__TestHdlrParams_tx__sccp__cr__data__len_defval;
const INTEGER& f__TestHdlrParams_tx__sccp__cr__data__len_defval = const_f__TestHdlrParams_tx__sccp__cr__data__len_defval;
BOOLEAN const_f__TestHdlrParams_expect__compl__l3__success_defval;
const BOOLEAN& f__TestHdlrParams_expect__compl__l3__success_defval = const_f__TestHdlrParams_expect__compl__l3__success_defval;
INTEGER const_f__TestHdlrParams_cn__nr_defval;
const INTEGER& f__TestHdlrParams_cn__nr_defval = const_f__TestHdlrParams_cn__nr_defval;
RANAP__IEs::Cause_template template_f__TestHdlrParams_rab__rel__cause_defval;
const RANAP__IEs::Cause_template& f__TestHdlrParams_rab__rel__cause_defval = template_f__TestHdlrParams_rab__rel__cause_defval;
INTEGER const_f__hnbap__hnb__register_hnb__idx_defval;
const INTEGER& f__hnbap__hnb__register_hnb__idx_defval = const_f__hnbap__hnb__register_hnb__idx_defval;
BOOLEAN const_f__hnbap__hnb__register_expect__reject_defval;
const BOOLEAN& f__hnbap__hnb__register_expect__reject_defval = const_f__hnbap__hnb__register_expect__reject_defval;
INTEGER const_f__hnbap__ue__register_hnb__idx_defval;
const INTEGER& f__hnbap__ue__register_hnb__idx_defval = const_f__hnbap__ue__register_hnb__idx_defval;
BOOLEAN const_f__hnbap__ue__register_expect__reject_defval;
const BOOLEAN& f__hnbap__ue__register_expect__reject_defval = const_f__hnbap__ue__register_expect__reject_defval;
Osmocom__CTRL__Functions::CounterNameVals const_counternames__hnb;
const Osmocom__CTRL__Functions::CounterNameVals& counternames__hnb = const_counternames__hnb;
INTEGER const_f__ctrs__hnb__init_hnb__start_defval;
const INTEGER& f__ctrs__hnb__init_hnb__start_defval = const_f__ctrs__hnb__init_hnb__start_defval;
INTEGER const_f__ctrs__hnb__init_hnb__count_defval;
const INTEGER& f__ctrs__hnb__init_hnb__count_defval = const_f__ctrs__hnb__init_hnb__count_defval;
Osmocom__CTRL__Functions::CounterNameVals const_f__ctrs__hnb__init_counternames_defval;
const Osmocom__CTRL__Functions::CounterNameVals& f__ctrs__hnb__init_counternames_defval = const_f__ctrs__hnb__init_counternames_defval;
INTEGER const_f__ctrs__hnb__expect_val_defval;
const INTEGER& f__ctrs__hnb__expect_val_defval = const_f__ctrs__hnb__expect_val_defval;
INTEGER const_f__ctrs__hnb__add_val_defval;
const INTEGER& f__ctrs__hnb__add_val_defval = const_f__ctrs__hnb__add_val_defval;
INTEGER const_f__vty__set__sccp__max__optional__data_val_defval;
const INTEGER& f__vty__set__sccp__max__optional__data_val_defval = const_f__vty__set__sccp__max__optional__data_val_defval;
const XERdescriptor_t       Testdata__CR__Limit_data__len_xer_ = { {"data_len>\n", "data_len>\n"}, {10, 10}, 0 |FORM_UNQUALIFIED, WHITESPACE_PRESERVE,  NULL, &module_object, -1, 0, NULL, NULL, -1, XSD_NONE };
const TTCN_Typedescriptor_t Testdata__CR__Limit_data__len_descr_ = { "@HNBGW_Tests.Testdata_CR_Limit.data_len", &INTEGER_ber_, &INTEGER_raw_, &INTEGER_text_, &Testdata__CR__Limit_data__len_xer_, &INTEGER_json_, NULL, NULL, NULL, TTCN_Typedescriptor_t::DONTCARE };
const XERdescriptor_t       Testdata__CR__Limit_max__optional__data_xer_ = { {"max_optional_data>\n", "max_optional_data>\n"}, {19, 19}, 0 |FORM_UNQUALIFIED, WHITESPACE_PRESERVE,  NULL, &module_object, -1, 0, NULL, NULL, -1, XSD_NONE };
const TTCN_Typedescriptor_t Testdata__CR__Limit_max__optional__data_descr_ = { "@HNBGW_Tests.Testdata_CR_Limit.max_optional_data", &INTEGER_ber_, &INTEGER_raw_, &INTEGER_text_, &Testdata__CR__Limit_max__optional__data_xer_, &INTEGER_json_, NULL, NULL, NULL, TTCN_Typedescriptor_t::DONTCARE };
const XERdescriptor_t       Testdata__CR__Limit_expect__separate__sccp__cr_xer_ = { {"expect_separate_sccp_cr>\n", "expect_separate_sccp_cr>\n"}, {25, 25}, 0 |FORM_UNQUALIFIED, WHITESPACE_PRESERVE,  NULL, &module_object, -1, 0, NULL, NULL, -1, XSD_NONE };
const int Testdata__CR__Limit_expect__separate__sccp__cr_oer_ext_arr_[0] = {};
const int Testdata__CR__Limit_expect__separate__sccp__cr_oer_p_[0] = {};
const TTCN_OERdescriptor_t Testdata__CR__Limit_expect__separate__sccp__cr_oer_ = { -1, TRUE, -1, FALSE, 0, 0, Testdata__CR__Limit_expect__separate__sccp__cr_oer_ext_arr_, 0, Testdata__CR__Limit_expect__separate__sccp__cr_oer_p_};
const TTCN_Typedescriptor_t Testdata__CR__Limit_expect__separate__sccp__cr_descr_ = { "@HNBGW_Tests.Testdata_CR_Limit.expect_separate_sccp_cr", &BOOLEAN_ber_, &BOOLEAN_raw_, &BOOLEAN_text_, &Testdata__CR__Limit_expect__separate__sccp__cr_xer_, &BOOLEAN_json_, &Testdata__CR__Limit_expect__separate__sccp__cr_oer_, NULL, NULL, TTCN_Typedescriptor_t::DONTCARE };
// No XER for Testdata__CR__Limit
const TTCN_Typedescriptor_t Testdata__CR__Limit_descr_ = { "@HNBGW_Tests.Testdata_CR_Limit", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, TTCN_Typedescriptor_t::DONTCARE };
// No XER for Testdata__CR__Limits
const TTCN_Typedescriptor_t Testdata__CR__Limits_descr_ = { "@HNBGW_Tests.Testdata_CR_Limits", NULL, NULL, NULL, NULL, NULL, NULL, NULL, &Testdata__CR__Limit_descr_, TTCN_Typedescriptor_t::DONTCARE };
Osmocom__CTRL__Functions::CounterNameVals const_counternames__cnpool;
const Osmocom__CTRL__Functions::CounterNameVals& counternames__cnpool = const_counternames__cnpool;
INTEGER const_f__ctrs__cn__init_cn__count_defval;
const INTEGER& f__ctrs__cn__init_cn__count_defval = const_f__ctrs__cn__init_cn__count_defval;
Osmocom__CTRL__Functions::CounterNameVals const_f__ctrs__cn__init_counternames_defval;
const Osmocom__CTRL__Functions::CounterNameVals& f__ctrs__cn__init_counternames_defval = const_f__ctrs__cn__init_counternames_defval;
INTEGER const_f__ctrs__cn__expect_val_defval;
const INTEGER& f__ctrs__cn__expect_val_defval = const_f__ctrs__cn__expect_val_defval;
INTEGER const_f__ctrs__cn__add_val_defval;
const INTEGER& f__ctrs__cn__add_val_defval = const_f__ctrs__cn__add_val_defval;
CHARSTRING_template template_f__TC__cnpool__compl__l3_inc__countername_defval;
const CHARSTRING_template& f__TC__cnpool__compl__l3_inc__countername_defval = template_f__TC__cnpool__compl__l3_inc__countername_defval;
BOOLEAN const_f__TC__cnpool__compl__l3_expect__compl__l3__success_defval;
const BOOLEAN& f__TC__cnpool__compl__l3_expect__compl__l3__success_defval = const_f__TC__cnpool__compl__l3_expect__compl__l3__success_defval;
BOOLEAN const_f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval;
const BOOLEAN& f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval = const_f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval;
// No XER for Compl3Type
const TTCN_Typedescriptor_t Compl3Type_descr_ = { "@HNBGW_Tests.Compl3Type", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, TTCN_Typedescriptor_t::DONTCARE };
INTEGER const_f__gen__one__compl__l3_ps__nri_defval;
const INTEGER& f__gen__one__compl__l3_ps__nri_defval = const_f__gen__one__compl__l3_ps__nri_defval;
// No XER for ro__Compl3Type
const TTCN_Typedescriptor_t ro__Compl3Type_descr_ = { "@HNBGW_Tests.ro_Compl3Type", NULL, NULL, NULL, NULL, NULL, NULL, NULL, &Compl3Type_descr_, TTCN_Typedescriptor_t::DONTCARE };
// No XER for ro__MobileIdentityLV
const TTCN_Typedescriptor_t ro__MobileIdentityLV_descr_ = { "@HNBGW_Tests.ro_MobileIdentityLV", NULL, NULL, NULL, NULL, NULL, NULL, NULL, &MobileL3__CommonIE__Types::MobileIdentityLV_descr_, TTCN_Typedescriptor_t::DONTCARE };
UNIVERSAL_CHARSTRING ro__MobileIdentityLV_0_default_coding("RAW");
// No XER for ro__octetstring
const TTCN_Typedescriptor_t ro__octetstring_descr_ = { "@HNBGW_Tests.ro_octetstring", NULL, NULL, NULL, NULL, NULL, NULL, NULL, &OCTETSTRING_descr_, TTCN_Typedescriptor_t::DONTCARE };
const XERdescriptor_t       ro__octetstring_0_xer_ = { {"OCTETSTRING>\n", "OCTETSTRING>\n"}, {13, 13}, 0 |FORM_UNQUALIFIED, WHITESPACE_PRESERVE,  NULL, &module_object, -1, 0, NULL, NULL, -1, XSD_NONE };
const int ro__octetstring_0_oer_ext_arr_[0] = {};
const int ro__octetstring_0_oer_p_[0] = {};
const TTCN_OERdescriptor_t ro__octetstring_0_oer_ = { -1, TRUE, -1, FALSE, 0, 0, ro__octetstring_0_oer_ext_arr_, 0, ro__octetstring_0_oer_p_};
const TTCN_Typedescriptor_t ro__octetstring_0_descr_ = { "@HNBGW_Tests.ro_octetstring.<oftype>", &OCTETSTRING_ber_, &OCTETSTRING_raw_, &OCTETSTRING_text_, &ro__octetstring_0_xer_, &OCTETSTRING_json_, &ro__octetstring_0_oer_, NULL, NULL, TTCN_Typedescriptor_t::DONTCARE };
ro__MobileIdentityLV_template template_f__gen__compl3__by__domain_mis_defval;
const ro__MobileIdentityLV_template& f__gen__compl3__by__domain_mis_defval = template_f__gen__compl3__by__domain_mis_defval;
INTEGER const_f__vty__add__sccp__addr_cs7__nr_defval;
const INTEGER& f__vty__add__sccp__addr_cs7__nr_defval = const_f__vty__add__sccp__addr_cs7__nr_defval;
TTCN_Module module_object("HNBGW_Tests", __DATE__, __TIME__, module_checksum, pre_init_module, NULL, 0U, 4294967295U, 4294967295U, 4294967295U, NULL, 0LU, 0, post_init_module, set_module_param, NULL, log_module_param, init_comp_type, init_system_port, start_ptc_function, module_control_part);

const RuntimeVersionChecker ver_checker(  current_runtime_version.requires_major_version_11,
  current_runtime_version.requires_minor_version_1,
  current_runtime_version.requires_patch_level_0,  current_runtime_version.requires_runtime_1);

/* Member functions of C++ classes */

as__Tguard_Default::as__Tguard_Default()
 : Default_Base("as_Tguard")
{
}

alt_status as__Tguard_Default::call_altstep(boolean first_alt_run)
{
return as__Tguard_instance(first_alt_run);
}

Testdata__CR__Limit::Testdata__CR__Limit()
{
}

Testdata__CR__Limit::Testdata__CR__Limit(const INTEGER& par_data__len,
    const INTEGER& par_max__optional__data,
    const BOOLEAN& par_expect__separate__sccp__cr)
  :   field_data__len(par_data__len),
  field_max__optional__data(par_max__optional__data),
  field_expect__separate__sccp__cr(par_expect__separate__sccp__cr)
{
}

Testdata__CR__Limit::Testdata__CR__Limit(const Testdata__CR__Limit& other_value)
{
if(!other_value.is_bound()) TTCN_error("Copying an unbound value of type @HNBGW_Tests.Testdata_CR_Limit.");
if (other_value.data__len().is_bound()) field_data__len = other_value.data__len();
else field_data__len.clean_up();
if (other_value.max__optional__data().is_bound()) field_max__optional__data = other_value.max__optional__data();
else field_max__optional__data.clean_up();
if (other_value.expect__separate__sccp__cr().is_bound()) field_expect__separate__sccp__cr = other_value.expect__separate__sccp__cr();
else field_expect__separate__sccp__cr.clean_up();
}

void Testdata__CR__Limit::clean_up()
{
field_data__len.clean_up();
field_max__optional__data.clean_up();
field_expect__separate__sccp__cr.clean_up();
}

const TTCN_Typedescriptor_t* Testdata__CR__Limit::get_descriptor() const { return &Testdata__CR__Limit_descr_; }
Testdata__CR__Limit& Testdata__CR__Limit::operator=(const Testdata__CR__Limit& other_value)
{
if (this != &other_value) {
  if(!other_value.is_bound()) TTCN_error("Assignment of an unbound value of type @HNBGW_Tests.Testdata_CR_Limit.");
  if (other_value.data__len().is_bound()) field_data__len = other_value.data__len();
  else field_data__len.clean_up();
  if (other_value.max__optional__data().is_bound()) field_max__optional__data = other_value.max__optional__data();
  else field_max__optional__data.clean_up();
  if (other_value.expect__separate__sccp__cr().is_bound()) field_expect__separate__sccp__cr = other_value.expect__separate__sccp__cr();
  else field_expect__separate__sccp__cr.clean_up();
}
return *this;
}

boolean Testdata__CR__Limit::operator==(const Testdata__CR__Limit& other_value) const
{
return field_data__len==other_value.field_data__len
  && field_max__optional__data==other_value.field_max__optional__data
  && field_expect__separate__sccp__cr==other_value.field_expect__separate__sccp__cr;
}

boolean Testdata__CR__Limit::is_bound() const
{
return (field_data__len.is_bound())
  || (field_max__optional__data.is_bound())
  || (field_expect__separate__sccp__cr.is_bound());
}
boolean Testdata__CR__Limit::is_value() const
{
return field_data__len.is_value()
  && field_max__optional__data.is_value()
  && field_expect__separate__sccp__cr.is_value();
}
void Testdata__CR__Limit::log() const
{
if (!is_bound()) {
TTCN_Logger::log_event_unbound();
return;
}
TTCN_Logger::log_event_str("{ data_len := ");
field_data__len.log();
TTCN_Logger::log_event_str(", max_optional_data := ");
field_max__optional__data.log();
TTCN_Logger::log_event_str(", expect_separate_sccp_cr := ");
field_expect__separate__sccp__cr.log();
TTCN_Logger::log_event_str(" }");
}

void Testdata__CR__Limit::set_implicit_omit()
{
if (data__len().is_bound()) data__len().set_implicit_omit();
if (max__optional__data().is_bound()) max__optional__data().set_implicit_omit();
if (expect__separate__sccp__cr().is_bound()) expect__separate__sccp__cr().set_implicit_omit();
}

void Testdata__CR__Limit::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_VALUE, "record value");
  switch (param.get_type()) {
  case Module_Param::MP_Value_List:
    if (3<param.get_size()) {
      param.error("record value of type @HNBGW_Tests.Testdata_CR_Limit has 3 fields but list value has %d fields", (int)param.get_size());
    }
    if (param.get_size()>0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) data__len().set_param(*param.get_elem(0));
    if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) max__optional__data().set_param(*param.get_elem(1));
    if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) expect__separate__sccp__cr().set_param(*param.get_elem(2));
    break;
  case Module_Param::MP_Assignment_List: {
    Vector<bool> value_used(param.get_size());
    value_used.resize(param.get_size(), FALSE);
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "data_len")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          data__len().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "max_optional_data")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          max__optional__data().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "expect_separate_sccp_cr")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          expect__separate__sccp__cr().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) if (!value_used[val_idx]) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      curr_param->error("Non existent field name in type @HNBGW_Tests.Testdata_CR_Limit: %s", curr_param->get_id()->get_name());
      break;
    }
  } break;
  default:
    param.type_error("record value", "@HNBGW_Tests.Testdata_CR_Limit");
  }
}

void Testdata__CR__Limit::encode_text(Text_Buf& text_buf) const
{
field_data__len.encode_text(text_buf);
field_max__optional__data.encode_text(text_buf);
field_expect__separate__sccp__cr.encode_text(text_buf);
}

void Testdata__CR__Limit::decode_text(Text_Buf& text_buf)
{
field_data__len.decode_text(text_buf);
field_max__optional__data.decode_text(text_buf);
field_expect__separate__sccp__cr.decode_text(text_buf);
}

struct Testdata__CR__Limit_template::single_value_struct {
INTEGER_template field_data__len;
INTEGER_template field_max__optional__data;
BOOLEAN_template field_expect__separate__sccp__cr;
};

void Testdata__CR__Limit_template::set_specific()
{
if (template_selection != SPECIFIC_VALUE) {
template_sel old_selection = template_selection;
clean_up();
single_value = new single_value_struct;
set_selection(SPECIFIC_VALUE);
if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) {
single_value->field_data__len = ANY_VALUE;
single_value->field_max__optional__data = ANY_VALUE;
single_value->field_expect__separate__sccp__cr = ANY_VALUE;
}
}
}

void Testdata__CR__Limit_template::copy_value(const Testdata__CR__Limit& other_value)
{
single_value = new single_value_struct;
if (other_value.data__len().is_bound()) {
  single_value->field_data__len = other_value.data__len();
} else {
  single_value->field_data__len.clean_up();
}
if (other_value.max__optional__data().is_bound()) {
  single_value->field_max__optional__data = other_value.max__optional__data();
} else {
  single_value->field_max__optional__data.clean_up();
}
if (other_value.expect__separate__sccp__cr().is_bound()) {
  single_value->field_expect__separate__sccp__cr = other_value.expect__separate__sccp__cr();
} else {
  single_value->field_expect__separate__sccp__cr.clean_up();
}
set_selection(SPECIFIC_VALUE);
}

void Testdata__CR__Limit_template::copy_template(const Testdata__CR__Limit_template& other_value)
{
switch (other_value.template_selection) {
case SPECIFIC_VALUE:
single_value = new single_value_struct;
if (UNINITIALIZED_TEMPLATE != other_value.data__len().get_selection()) {
single_value->field_data__len = other_value.data__len();
} else {
single_value->field_data__len.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.max__optional__data().get_selection()) {
single_value->field_max__optional__data = other_value.max__optional__data();
} else {
single_value->field_max__optional__data.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.expect__separate__sccp__cr().get_selection()) {
single_value->field_expect__separate__sccp__cr = other_value.expect__separate__sccp__cr();
} else {
single_value->field_expect__separate__sccp__cr.clean_up();
}
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
value_list.n_values = other_value.value_list.n_values;
value_list.list_value = new Testdata__CR__Limit_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]);
break;
case IMPLICATION_MATCH:
implication_.precondition = new Testdata__CR__Limit_template(*other_value.implication_.precondition);
implication_.implied_template = new Testdata__CR__Limit_template(*other_value.implication_.implied_template);
break;
case DYNAMIC_MATCH:
dyn_match = other_value.dyn_match;
dyn_match->ref_count++;
break;
default:
TTCN_error("Copying an uninitialized/unsupported template of type @HNBGW_Tests.Testdata_CR_Limit.");
break;
}
set_selection(other_value);
}

Testdata__CR__Limit_template::Testdata__CR__Limit_template()
{
}

Testdata__CR__Limit_template::Testdata__CR__Limit_template(template_sel other_value)
 : Base_Template(other_value)
{
check_single_selection(other_value);
}

Testdata__CR__Limit_template::Testdata__CR__Limit_template(const Testdata__CR__Limit& other_value)
{
copy_value(other_value);
}

Testdata__CR__Limit_template::Testdata__CR__Limit_template(const OPTIONAL<Testdata__CR__Limit>& other_value)
{
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const Testdata__CR__Limit&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Creating a template of type @HNBGW_Tests.Testdata_CR_Limit from an unbound optional field.");
}
}

Testdata__CR__Limit_template::Testdata__CR__Limit_template(Testdata__CR__Limit_template* p_precondition, Testdata__CR__Limit_template* p_implied_template)
 : Base_Template(IMPLICATION_MATCH)
{
implication_.precondition = p_precondition;
implication_.implied_template = p_implied_template;
}

Testdata__CR__Limit_template::Testdata__CR__Limit_template(Dynamic_Match_Interface<Testdata__CR__Limit>* p_dyn_match)
 : Base_Template(DYNAMIC_MATCH)
{
dyn_match = new dynmatch_struct<Testdata__CR__Limit>;
dyn_match->ptr = p_dyn_match;
dyn_match->ref_count = 1;
}

Testdata__CR__Limit_template::Testdata__CR__Limit_template(const Testdata__CR__Limit_template& other_value)
: Base_Template()
{
copy_template(other_value);
}

Testdata__CR__Limit_template::~Testdata__CR__Limit_template()
{
clean_up();
}

Testdata__CR__Limit_template& Testdata__CR__Limit_template::operator=(template_sel other_value)
{
check_single_selection(other_value);
clean_up();
set_selection(other_value);
return *this;
}

Testdata__CR__Limit_template& Testdata__CR__Limit_template::operator=(const Testdata__CR__Limit& other_value)
{
clean_up();
copy_value(other_value);
return *this;
}

Testdata__CR__Limit_template& Testdata__CR__Limit_template::operator=(const OPTIONAL<Testdata__CR__Limit>& other_value)
{
clean_up();
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const Testdata__CR__Limit&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Assignment of an unbound optional field to a template of type @HNBGW_Tests.Testdata_CR_Limit.");
}
return *this;
}

Testdata__CR__Limit_template& Testdata__CR__Limit_template::operator=(const Testdata__CR__Limit_template& other_value)
{
if (&other_value != this) {
clean_up();
copy_template(other_value);
}
return *this;
}

boolean Testdata__CR__Limit_template::match(const Testdata__CR__Limit& other_value, boolean legacy) const
{
if (!other_value.is_bound()) return FALSE;
switch (template_selection) {
case ANY_VALUE:
case ANY_OR_OMIT:
return TRUE;
case OMIT_VALUE:
return FALSE;
case SPECIFIC_VALUE:
if(!other_value.data__len().is_bound()) return FALSE;
if(!single_value->field_data__len.match(other_value.data__len(), legacy))return FALSE;
if(!other_value.max__optional__data().is_bound()) return FALSE;
if(!single_value->field_max__optional__data.match(other_value.max__optional__data(), legacy))return FALSE;
if(!other_value.expect__separate__sccp__cr().is_bound()) return FALSE;
if(!single_value->field_expect__separate__sccp__cr.match(other_value.expect__separate__sccp__cr(), legacy))return FALSE;
return TRUE;
case VALUE_LIST:
case COMPLEMENTED_LIST:
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST;
return template_selection == COMPLEMENTED_LIST;
case CONJUNCTION_MATCH:
for (unsigned int i = 0; i < value_list.n_values; i++) {
if (!value_list.list_value[i].match(other_value)) {
return FALSE;
}
}
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value);
case DYNAMIC_MATCH:
return dyn_match->ptr->match(other_value);
default:
TTCN_error("Matching an uninitialized/unsupported template of type @HNBGW_Tests.Testdata_CR_Limit.");
}
return FALSE;
}

boolean Testdata__CR__Limit_template::is_bound() const
{
if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE;
if (template_selection != SPECIFIC_VALUE) return TRUE;
return single_value->field_data__len.is_bound()
 || single_value->field_max__optional__data.is_bound()
 || single_value->field_expect__separate__sccp__cr.is_bound();
}

boolean Testdata__CR__Limit_template::is_value() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE;
return single_value->field_data__len.is_value()
 && single_value->field_max__optional__data.is_value()
 && single_value->field_expect__separate__sccp__cr.is_value();
}

void Testdata__CR__Limit_template::clean_up()
{
switch (template_selection) {
case SPECIFIC_VALUE:
delete single_value;
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
delete [] value_list.list_value;
break;
case IMPLICATION_MATCH:
delete implication_.precondition;
delete implication_.implied_template;
break;
case DYNAMIC_MATCH:
dyn_match->ref_count--;
if (dyn_match->ref_count == 0) {
delete dyn_match->ptr;
delete dyn_match;
}
break;
default:
break;
}
template_selection = UNINITIALIZED_TEMPLATE;
}

Testdata__CR__Limit Testdata__CR__Limit_template::valueof() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent)
TTCN_error("Performing a valueof or send operation on a non-specific template of type @HNBGW_Tests.Testdata_CR_Limit.");
Testdata__CR__Limit ret_val;
if (single_value->field_data__len.is_bound()) {
ret_val.data__len() = single_value->field_data__len.valueof();
}
if (single_value->field_max__optional__data.is_bound()) {
ret_val.max__optional__data() = single_value->field_max__optional__data.valueof();
}
if (single_value->field_expect__separate__sccp__cr.is_bound()) {
ret_val.expect__separate__sccp__cr() = single_value->field_expect__separate__sccp__cr.valueof();
}
return ret_val;
}

void Testdata__CR__Limit_template::set_type(template_sel template_type, unsigned int list_length)
{
if (template_type != VALUE_LIST && template_type != COMPLEMENTED_LIST&& template_type != CONJUNCTION_MATCH)
TTCN_error("Setting an invalid list for a template of type @HNBGW_Tests.Testdata_CR_Limit.");
clean_up();
set_selection(template_type);
value_list.n_values = list_length;
value_list.list_value = new Testdata__CR__Limit_template[list_length];
}

Testdata__CR__Limit_template& Testdata__CR__Limit_template::list_item(unsigned int list_index) const
{
if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST&& template_selection != CONJUNCTION_MATCH)
TTCN_error("Accessing a list element of a non-list template of type @HNBGW_Tests.Testdata_CR_Limit.");
if (list_index >= value_list.n_values)
TTCN_error("Index overflow in a value list template of type @HNBGW_Tests.Testdata_CR_Limit.");
return value_list.list_value[list_index];
}

INTEGER_template& Testdata__CR__Limit_template::data__len()
{
set_specific();
return single_value->field_data__len;
}

const INTEGER_template& Testdata__CR__Limit_template::data__len() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field data_len of a non-specific template of type @HNBGW_Tests.Testdata_CR_Limit.");
return single_value->field_data__len;
}

INTEGER_template& Testdata__CR__Limit_template::max__optional__data()
{
set_specific();
return single_value->field_max__optional__data;
}

const INTEGER_template& Testdata__CR__Limit_template::max__optional__data() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field max_optional_data of a non-specific template of type @HNBGW_Tests.Testdata_CR_Limit.");
return single_value->field_max__optional__data;
}

BOOLEAN_template& Testdata__CR__Limit_template::expect__separate__sccp__cr()
{
set_specific();
return single_value->field_expect__separate__sccp__cr;
}

const BOOLEAN_template& Testdata__CR__Limit_template::expect__separate__sccp__cr() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field expect_separate_sccp_cr of a non-specific template of type @HNBGW_Tests.Testdata_CR_Limit.");
return single_value->field_expect__separate__sccp__cr;
}

int Testdata__CR__Limit_template::size_of() const
{
  if (is_ifpresent) TTCN_error("Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit which has an ifpresent attribute.");
  switch (template_selection)
  {
  case SPECIFIC_VALUE:
    return 3;
  case VALUE_LIST:
   {
     if (value_list.n_values<1)
       TTCN_error("Internal error: Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit containing an empty list.");
      int item_size = value_list.list_value[0].size_of();
      for (unsigned int l_idx = 1; l_idx < value_list.n_values; l_idx++)
      {
        if (value_list.list_value[l_idx].size_of()!=item_size)
          TTCN_error("Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit containing a value list with different sizes.");
      }
      return item_size;
    }
  case OMIT_VALUE:
    TTCN_error("Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit containing omit value.");
  case ANY_VALUE:
  case ANY_OR_OMIT:
    TTCN_error("Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit containing */? value.");
  case COMPLEMENTED_LIST:
    TTCN_error("Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit containing complemented list.");
  case CONJUNCTION_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit containing a conjunction list match.");
  case IMPLICATION_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit containing an implication match.");
  case DYNAMIC_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limit containing a dynamic match.");
  default:
    TTCN_error("Performing sizeof() operation on an uninitialized/unsupported template of type @HNBGW_Tests.Testdata_CR_Limit.");
  }
  return 0;
}

void Testdata__CR__Limit_template::log() const
{
switch (template_selection) {
case SPECIFIC_VALUE:
TTCN_Logger::log_event_str("{ data_len := ");
single_value->field_data__len.log();
TTCN_Logger::log_event_str(", max_optional_data := ");
single_value->field_max__optional__data.log();
TTCN_Logger::log_event_str(", expect_separate_sccp_cr := ");
single_value->field_expect__separate__sccp__cr.log();
TTCN_Logger::log_event_str(" }");
break;
case COMPLEMENTED_LIST:
TTCN_Logger::log_event_str("complement");
case CONJUNCTION_MATCH:
if (template_selection == CONJUNCTION_MATCH) {
TTCN_Logger::log_event_str("conjunct");
}
case VALUE_LIST:
TTCN_Logger::log_char('(');
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) {
if (list_count > 0) TTCN_Logger::log_event_str(", ");
value_list.list_value[list_count].log();
}
TTCN_Logger::log_char(')');
break;
case IMPLICATION_MATCH:
implication_.precondition->log();
TTCN_Logger::log_event_str(" implies ");
implication_.implied_template->log();
break;
case DYNAMIC_MATCH:
TTCN_Logger::log_event_str("@dynamic template");
break;
default:
log_generic();
}
log_ifpresent();
}

void Testdata__CR__Limit_template::log_match(const Testdata__CR__Limit& match_value, boolean legacy) const
{
if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){
if(match(match_value, legacy)){
TTCN_Logger::print_logmatch_buffer();
TTCN_Logger::log_event_str(" matched");
} else{
if (template_selection == SPECIFIC_VALUE) {
size_t previous_size = TTCN_Logger::get_logmatch_buffer_len();
if(!single_value->field_data__len.match(match_value.data__len(), legacy)){
TTCN_Logger::log_logmatch_info(".data_len");
single_value->field_data__len.log_match(match_value.data__len(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_max__optional__data.match(match_value.max__optional__data(), legacy)){
TTCN_Logger::log_logmatch_info(".max_optional_data");
single_value->field_max__optional__data.log_match(match_value.max__optional__data(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_expect__separate__sccp__cr.match(match_value.expect__separate__sccp__cr(), legacy)){
TTCN_Logger::log_logmatch_info(".expect_separate_sccp_cr");
single_value->field_expect__separate__sccp__cr.log_match(match_value.expect__separate__sccp__cr(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
}else {
TTCN_Logger::print_logmatch_buffer();
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
TTCN_Logger::log_event_str(" unmatched");
}
}
return;
}
if (template_selection == SPECIFIC_VALUE) {
TTCN_Logger::log_event_str("{ data_len := ");
single_value->field_data__len.log_match(match_value.data__len(), legacy);
TTCN_Logger::log_event_str(", max_optional_data := ");
single_value->field_max__optional__data.log_match(match_value.max__optional__data(), legacy);
TTCN_Logger::log_event_str(", expect_separate_sccp_cr := ");
single_value->field_expect__separate__sccp__cr.log_match(match_value.expect__separate__sccp__cr(), legacy);
TTCN_Logger::log_event_str(" }");
} else {
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched");
else TTCN_Logger::log_event_str(" unmatched");
}
}

void Testdata__CR__Limit_template::set_implicit_omit()
{
if (template_selection != SPECIFIC_VALUE) return;
if (data__len().is_bound()) data__len().set_implicit_omit();
if (max__optional__data().is_bound()) max__optional__data().set_implicit_omit();
if (expect__separate__sccp__cr().is_bound()) expect__separate__sccp__cr().set_implicit_omit();
}

void Testdata__CR__Limit_template::encode_text(Text_Buf& text_buf) const
{
encode_text_base(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value->field_data__len.encode_text(text_buf);
single_value->field_max__optional__data.encode_text(text_buf);
single_value->field_expect__separate__sccp__cr.encode_text(text_buf);
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
text_buf.push_int(value_list.n_values);
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].encode_text(text_buf);
break;
default:
TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @HNBGW_Tests.Testdata_CR_Limit.");
}
}

void Testdata__CR__Limit_template::decode_text(Text_Buf& text_buf)
{
clean_up();
decode_text_base(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value = new single_value_struct;
single_value->field_data__len.decode_text(text_buf);
single_value->field_max__optional__data.decode_text(text_buf);
single_value->field_expect__separate__sccp__cr.decode_text(text_buf);
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
value_list.n_values = text_buf.pull_int().get_val();
value_list.list_value = new Testdata__CR__Limit_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].decode_text(text_buf);
break;
default:
TTCN_error("Text decoder: An unknown/unsupported selection was received in a template of type @HNBGW_Tests.Testdata_CR_Limit.");
}
}

void Testdata__CR__Limit_template::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_TEMPLATE, "record template");
  switch (param.get_type()) {
  case Module_Param::MP_Omit:
    *this = OMIT_VALUE;
    break;
  case Module_Param::MP_Any:
    *this = ANY_VALUE;
    break;
  case Module_Param::MP_AnyOrNone:
    *this = ANY_OR_OMIT;
    break;
  case Module_Param::MP_List_Template:
  case Module_Param::MP_ComplementList_Template:
  case Module_Param::MP_ConjunctList_Template: {
    Testdata__CR__Limit_template new_temp;
    new_temp.set_type(param.get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (param.get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), param.get_size());
    for (size_t p_i=0; p_i<param.get_size(); p_i++) {
      new_temp.list_item(p_i).set_param(*param.get_elem(p_i));
    }
    *this = new_temp;
    break; }
  case Module_Param::MP_Value_List:
    if (3<param.get_size()) {
      param.error("record template of type @HNBGW_Tests.Testdata_CR_Limit has 3 fields but list value has %d fields", (int)param.get_size());
    }
    if (param.get_size()>0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) data__len().set_param(*param.get_elem(0));
    if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) max__optional__data().set_param(*param.get_elem(1));
    if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) expect__separate__sccp__cr().set_param(*param.get_elem(2));
    break;
  case Module_Param::MP_Assignment_List: {
    Vector<bool> value_used(param.get_size());
    value_used.resize(param.get_size(), FALSE);
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "data_len")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          data__len().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "max_optional_data")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          max__optional__data().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "expect_separate_sccp_cr")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          expect__separate__sccp__cr().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) if (!value_used[val_idx]) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      curr_param->error("Non existent field name in type @HNBGW_Tests.Testdata_CR_Limit: %s", curr_param->get_id()->get_name());
      break;
    }
  } break;
  case Module_Param::MP_Implication_Template: {
    Testdata__CR__Limit_template* precondition = new Testdata__CR__Limit_template;
    precondition->set_param(*param.get_elem(0));
    Testdata__CR__Limit_template* implied_template = new Testdata__CR__Limit_template;
    implied_template->set_param(*param.get_elem(1));
    *this = Testdata__CR__Limit_template(precondition, implied_template);
  } break;
  default:
    param.type_error("record template", "@HNBGW_Tests.Testdata_CR_Limit");
  }
  is_ifpresent = param.get_ifpresent();
}

void Testdata__CR__Limit_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return;
switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) {
case TR_OMIT:
if (template_selection==OMIT_VALUE) return;
case TR_VALUE:
if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break;
single_value->field_data__len.check_restriction(t_res, t_name ? t_name : "@HNBGW_Tests.Testdata_CR_Limit");
single_value->field_max__optional__data.check_restriction(t_res, t_name ? t_name : "@HNBGW_Tests.Testdata_CR_Limit");
single_value->field_expect__separate__sccp__cr.check_restriction(t_res, t_name ? t_name : "@HNBGW_Tests.Testdata_CR_Limit");
return;
case TR_PRESENT:
if (!match_omit(legacy)) return;
break;
default:
return;
}
TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@HNBGW_Tests.Testdata_CR_Limit");
}

boolean Testdata__CR__Limit_template::is_present(boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE;
return !match_omit(legacy);
}

boolean Testdata__CR__Limit_template::match_omit(boolean legacy) const
{
if (is_ifpresent) return TRUE;
switch (template_selection) {
case OMIT_VALUE:
case ANY_OR_OMIT:
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match_omit() || implication_.implied_template->match_omit();
case VALUE_LIST:
case COMPLEMENTED_LIST:
if (legacy) {
for (unsigned int l_idx=0; l_idx<value_list.n_values; l_idx++)
if (value_list.list_value[l_idx].match_omit())
return template_selection==VALUE_LIST;
return template_selection==COMPLEMENTED_LIST;
} // else fall through
default:
return FALSE;
}
return FALSE;
}


const Testdata__CR__Limit Testdata__CR__Limits::UNBOUND_ELEM;
Testdata__CR__Limits::Testdata__CR__Limits()
{
val_ptr = NULL;
}

Testdata__CR__Limits::Testdata__CR__Limits(null_type)
{
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
}

Testdata__CR__Limits::Testdata__CR__Limits(const Testdata__CR__Limits& other_value)
{
if (!other_value.is_bound()) TTCN_error("Copying an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
val_ptr = other_value.val_ptr;
val_ptr->ref_count++;
}

Testdata__CR__Limits::~Testdata__CR__Limits()
{
clean_up();
if (val_ptr != NULL) val_ptr = NULL;
}

void Testdata__CR__Limits::clean_up()
{
if (val_ptr != NULL) {
if (val_ptr->ref_count > 1) {
val_ptr->ref_count--;
val_ptr = NULL;
}
else if (val_ptr->ref_count == 1) {
for (int elem_count = 0; elem_count < val_ptr->n_elements;
elem_count++)
if (val_ptr->value_elements[elem_count] != NULL)
delete val_ptr->value_elements[elem_count];
free_pointers((void**)val_ptr->value_elements);
delete val_ptr;
val_ptr = NULL;
}
else
TTCN_error("Internal error: Invalid reference counter in a record of/set of value.");
}
}

Testdata__CR__Limits& Testdata__CR__Limits::operator=(null_type)
{
clean_up();
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
return *this;
}

Testdata__CR__Limits& Testdata__CR__Limits::operator=(const Testdata__CR__Limits& other_value)
{
if (other_value.val_ptr == NULL) TTCN_error("Assigning an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
if (this != &other_value) {
clean_up();
val_ptr = other_value.val_ptr;
val_ptr->ref_count++;
}
return *this;
}

boolean Testdata__CR__Limits::operator==(null_type) const
{
if (val_ptr == NULL)
TTCN_error("The left operand of comparison is an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
return val_ptr->n_elements == 0 ;
}

boolean Testdata__CR__Limits::operator==(const Testdata__CR__Limits& other_value) const
{
if (val_ptr == NULL) TTCN_error("The left operand of comparison is an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
if (val_ptr == other_value.val_ptr) return TRUE;
if (val_ptr->n_elements != (other_value.val_ptr)->n_elements)
return FALSE;
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++){
if (val_ptr->value_elements[elem_count] != NULL){
if ((other_value.val_ptr)->value_elements[elem_count] != NULL){
  if (*val_ptr->value_elements[elem_count] != *(other_value.val_ptr)->value_elements[elem_count]) return FALSE;
} else return FALSE;
} else {
if ((other_value.val_ptr)->value_elements[elem_count] != NULL) return FALSE;
}
}
return TRUE;
}

Testdata__CR__Limit& Testdata__CR__Limits::operator[](int index_value)
{
if (index_value < 0) TTCN_error("Accessing an element of type @HNBGW_Tests.Testdata_CR_Limits using a negative index: %d.", index_value);
if (val_ptr == NULL) {
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
} else if (val_ptr->ref_count > 1) {
struct recordof_setof_struct *new_val_ptr = new recordof_setof_struct;
new_val_ptr->ref_count = 1;
new_val_ptr->n_elements = (index_value >= val_ptr->n_elements) ? index_value + 1 : val_ptr->n_elements;
new_val_ptr->value_elements = (Testdata__CR__Limit**)allocate_pointers(new_val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++){
if (val_ptr->value_elements[elem_count] != NULL){
new_val_ptr->value_elements[elem_count] = new Testdata__CR__Limit(*(val_ptr->value_elements[elem_count]));
}
}
clean_up();
val_ptr = new_val_ptr;
}
if (index_value >= val_ptr->n_elements) set_size(index_value + 1);
if (val_ptr->value_elements[index_value] == NULL) {
val_ptr->value_elements[index_value] = new Testdata__CR__Limit;
}
return *val_ptr->value_elements[index_value];
}

Testdata__CR__Limit& Testdata__CR__Limits::operator[](const INTEGER& index_value)
{
index_value.must_bound("Using an unbound integer value for indexing a value of type @HNBGW_Tests.Testdata_CR_Limits.");
return (*this)[(int)index_value];
}

const Testdata__CR__Limit& Testdata__CR__Limits::operator[](int index_value) const
{
if (val_ptr == NULL)
TTCN_error("Accessing an element in an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
if (index_value < 0) TTCN_error("Accessing an element of type @HNBGW_Tests.Testdata_CR_Limits using a negative index: %d.", index_value);
if (index_value >= val_ptr->n_elements) TTCN_error("Index overflow in a value of type @HNBGW_Tests.Testdata_CR_Limits: The index is %d, but the value has only %d elements.", index_value, val_ptr->n_elements);
return (val_ptr->value_elements[index_value] == NULL) ?
UNBOUND_ELEM : *val_ptr->value_elements[index_value];
}

const Testdata__CR__Limit& Testdata__CR__Limits::operator[](const INTEGER& index_value) const
{
index_value.must_bound("Using an unbound integer value for indexing a value of type @HNBGW_Tests.Testdata_CR_Limits.");
return (*this)[(int)index_value];
}

Testdata__CR__Limits Testdata__CR__Limits::operator<<=(int rotate_count) const
{
return *this >>= (-rotate_count);
}

Testdata__CR__Limits Testdata__CR__Limits::operator<<=(const INTEGER& rotate_count) const
{
rotate_count.must_bound("Unbound integer operand of rotate left operator.");
return *this >>= (int)(-rotate_count);
}

Testdata__CR__Limits Testdata__CR__Limits::operator>>=(const INTEGER& rotate_count) const
{
rotate_count.must_bound("Unbound integer operand of rotate right operator.");
return *this >>= (int)rotate_count;
}

Testdata__CR__Limits Testdata__CR__Limits::operator>>=(int rotate_count) const
{
if (val_ptr == NULL) TTCN_error("Performing rotation operation on an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
if (val_ptr->n_elements == 0) return *this;
int rc;
if (rotate_count>=0) rc = rotate_count % val_ptr->n_elements;
else rc = val_ptr->n_elements - ((-rotate_count) % val_ptr->n_elements);
if (rc == 0) return *this;
Testdata__CR__Limits ret_val;
ret_val.set_size(val_ptr->n_elements);
for (int i=0; i<val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[(i+rc)%val_ptr->n_elements] =new Testdata__CR__Limit(*val_ptr->value_elements[i]);
}
}
return ret_val;
}

Testdata__CR__Limits Testdata__CR__Limits::operator+(const Testdata__CR__Limits& other_value) const
{
if (val_ptr == NULL || other_value.val_ptr == NULL) TTCN_error("Unbound operand of @HNBGW_Tests.Testdata_CR_Limits concatenation.");
if (val_ptr->n_elements == 0) return other_value;
if (other_value.val_ptr->n_elements == 0) return *this;
Testdata__CR__Limits ret_val;
ret_val.set_size(val_ptr->n_elements+other_value.val_ptr->n_elements);
for (int i=0; i<val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i] = new Testdata__CR__Limit(*val_ptr->value_elements[i]);
}
}
for (int i=0; i<other_value.val_ptr->n_elements; i++) {
if (other_value.val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i+val_ptr->n_elements] = new Testdata__CR__Limit(*other_value.val_ptr->value_elements[i]);
}
}
return ret_val;
}

Testdata__CR__Limits Testdata__CR__Limits::substr(int index, int returncount) const
{
if (val_ptr == NULL) TTCN_error("The first argument of substr() is an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
check_substr_arguments(val_ptr->n_elements, index, returncount, "@HNBGW_Tests.Testdata_CR_Limits","element");
Testdata__CR__Limits ret_val;
ret_val.set_size(returncount);
for (int i=0; i<returncount; i++) {
if (val_ptr->value_elements[i+index] != NULL) {
ret_val.val_ptr->value_elements[i] = new Testdata__CR__Limit(*val_ptr->value_elements[i+index]);
}
}
return ret_val;
}

Testdata__CR__Limits Testdata__CR__Limits::replace(int index, int len, const Testdata__CR__Limits& repl) const
{
if (val_ptr == NULL) TTCN_error("The first argument of replace() is an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
if (repl.val_ptr == NULL) TTCN_error("The fourth argument of replace() is an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
check_replace_arguments(val_ptr->n_elements, index, len, "@HNBGW_Tests.Testdata_CR_Limits","element");
Testdata__CR__Limits ret_val;
ret_val.set_size(val_ptr->n_elements + repl.val_ptr->n_elements - len);
for (int i = 0; i < index; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i] = new Testdata__CR__Limit(*val_ptr->value_elements[i]);
}
}
for (int i = 0; i < repl.val_ptr->n_elements; i++) {
if (repl.val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i+index] = new Testdata__CR__Limit(*repl.val_ptr->value_elements[i]);
}
}
for (int i = 0; i < val_ptr->n_elements - index - len; i++) {
if (val_ptr->value_elements[index+i+len] != NULL) {
ret_val.val_ptr->value_elements[index+i+repl.val_ptr->n_elements] = new Testdata__CR__Limit(*val_ptr->value_elements[index+i+len]);
}
}
return ret_val;
}

Testdata__CR__Limits Testdata__CR__Limits::replace(int index, int len, const Testdata__CR__Limits_template& repl) const
{
if (!repl.is_value()) TTCN_error("The fourth argument of function replace() is a template with non-specific value.");
return replace(index, len, repl.valueof());
}

void Testdata__CR__Limits::set_size(int new_size)
{
if (new_size < 0) TTCN_error("Internal error: Setting a negative size for a value of type @HNBGW_Tests.Testdata_CR_Limits.");
if (val_ptr == NULL) {
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
} else if (val_ptr->ref_count > 1) {
struct recordof_setof_struct *new_val_ptr = new recordof_setof_struct;
new_val_ptr->ref_count = 1;
new_val_ptr->n_elements = (new_size < val_ptr->n_elements) ? new_size : val_ptr->n_elements;
new_val_ptr->value_elements = (Testdata__CR__Limit**)allocate_pointers(new_val_ptr->n_elements);
for (int elem_count = 0; elem_count < new_val_ptr->n_elements; elem_count++) {
if (val_ptr->value_elements[elem_count] != NULL){
new_val_ptr->value_elements[elem_count] = new Testdata__CR__Limit(*(val_ptr->value_elements[elem_count]));
}
}
clean_up();
val_ptr = new_val_ptr;
}
if (new_size > val_ptr->n_elements) {
val_ptr->value_elements = (Testdata__CR__Limit**)reallocate_pointers((void**)val_ptr->value_elements, val_ptr->n_elements, new_size);
#ifdef TITAN_MEMORY_DEBUG_SET_RECORD_OF
if((val_ptr->n_elements/1000)!=(new_size/1000)) TTCN_warning("New size of type @HNBGW_Tests.Testdata_CR_Limits: %d",new_size);
#endif
val_ptr->n_elements = new_size;
} else if (new_size < val_ptr->n_elements) {
for (int elem_count = new_size; elem_count < val_ptr->n_elements; elem_count++)
if (val_ptr->value_elements[elem_count] != NULL)delete val_ptr->value_elements[elem_count];
val_ptr->value_elements = (Testdata__CR__Limit**)reallocate_pointers((void**)val_ptr->value_elements, val_ptr->n_elements, new_size);
val_ptr->n_elements = new_size;
}
}

boolean Testdata__CR__Limits::is_value() const
{
if (val_ptr == NULL) return FALSE;
for(int i = 0; i < val_ptr->n_elements; ++i) {
if (val_ptr->value_elements[i] == NULL || !val_ptr->value_elements[i]->is_value()) return FALSE;
}
return TRUE;
}

int Testdata__CR__Limits::size_of() const
{
if (val_ptr == NULL) TTCN_error("Performing sizeof operation on an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
return val_ptr->n_elements;
}

int Testdata__CR__Limits::lengthof() const
{
if (val_ptr == NULL) TTCN_error("Performing lengthof operation on an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
for (int my_length=val_ptr->n_elements; my_length>0; my_length--) if (val_ptr->value_elements[my_length-1] != NULL) return my_length;
return 0;
}

void Testdata__CR__Limits::log() const
{
if (val_ptr == NULL) {;
TTCN_Logger::log_event_unbound();
return;
}
switch (val_ptr->n_elements) {
case 0:
TTCN_Logger::log_event_str("{ }");
break;
default:
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
(*this)[elem_count].log();
}
TTCN_Logger::log_event_str(" }");
}
}

void Testdata__CR__Limits::set_implicit_omit()
{
if (val_ptr == NULL) return;
for (int i = 0; i < val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) val_ptr->value_elements[i]->set_implicit_omit();
}
}

void Testdata__CR__Limits::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_VALUE|Module_Param::BC_LIST, "record of value");
  switch (param.get_operation_type()) {
  case Module_Param::OT_ASSIGN:
    if (param.get_type()==Module_Param::MP_Value_List && param.get_size()==0) {
      *this = NULL_VALUE;
      return;
    }
    switch (param.get_type()) {
    case Module_Param::MP_Value_List:
      set_size(param.get_size());
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        if (curr->get_type()!=Module_Param::MP_NotUsed) {
          (*this)[i].set_param(*curr);
          if (!(*this)[i].is_bound()) {
            delete val_ptr->value_elements[i];
            val_ptr->value_elements[i] = NULL;
          }
        }
      }
      break;
    case Module_Param::MP_Indexed_List:
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        (*this)[curr->get_id()->get_index()].set_param(*curr);
        if (!(*this)[curr->get_id()->get_index()].is_bound()) {
          delete val_ptr->value_elements[curr->get_id()->get_index()];
          val_ptr->value_elements[curr->get_id()->get_index()] = NULL;
        }
      }
      break;
    default:
      param.type_error("record of value", "@HNBGW_Tests.Testdata_CR_Limits");
    }
    break;
  case Module_Param::OT_CONCAT:
    switch (param.get_type()) {
    case Module_Param::MP_Value_List: {
      if (!is_bound()) *this = NULL_VALUE;
      int start_idx = lengthof();
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        if ((curr->get_type()!=Module_Param::MP_NotUsed)) {
          (*this)[start_idx+(int)i].set_param(*curr);
        }
      }
    } break;
    case Module_Param::MP_Indexed_List:
      param.error("Cannot concatenate an indexed value list");
      break;
    default:
      param.type_error("record of value", "@HNBGW_Tests.Testdata_CR_Limits");
    }
    break;
  default:
    TTCN_error("Internal error: Unknown operation type.");
  }
}

void Testdata__CR__Limits::encode_text(Text_Buf& text_buf) const
{
if (val_ptr == NULL) TTCN_error("Text encoder: Encoding an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
text_buf.push_int(val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++)
(*this)[elem_count].encode_text(text_buf);
}

void Testdata__CR__Limits::decode_text(Text_Buf& text_buf)
{
clean_up();
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = text_buf.pull_int().get_val();
if (val_ptr->n_elements < 0) TTCN_error("Text decoder: Negative size was received for a value of type @HNBGW_Tests.Testdata_CR_Limits.");
val_ptr->value_elements = (Testdata__CR__Limit**)allocate_pointers(val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) {
val_ptr->value_elements[elem_count] = new Testdata__CR__Limit;
val_ptr->value_elements[elem_count]->decode_text(text_buf);
}
}

void Testdata__CR__Limits_template::copy_value(const Testdata__CR__Limits& other_value)
{
if (!other_value.is_bound()) TTCN_error("Initialization of a template of type @HNBGW_Tests.Testdata_CR_Limits with an unbound value.");
single_value.n_elements = other_value.size_of();
single_value.value_elements = (Testdata__CR__Limit_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (other_value[elem_count].is_bound()) {
single_value.value_elements[elem_count] = new Testdata__CR__Limit_template(other_value[elem_count]);
} else {
single_value.value_elements[elem_count] = new Testdata__CR__Limit_template;
}
}
set_selection(SPECIFIC_VALUE);
}

void Testdata__CR__Limits_template::copy_template(const Testdata__CR__Limits_template& other_value)
{
switch (other_value.template_selection) {
case SPECIFIC_VALUE:
single_value.n_elements = other_value.single_value.n_elements;
single_value.value_elements = (Testdata__CR__Limit_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (UNINITIALIZED_TEMPLATE != other_value.single_value.value_elements[elem_count]->get_selection()) {
single_value.value_elements[elem_count] = new Testdata__CR__Limit_template(*other_value.single_value.value_elements[elem_count]);
} else {
single_value.value_elements[elem_count] = new Testdata__CR__Limit_template;
}
}
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
value_list.n_values = other_value.value_list.n_values;
value_list.list_value = new Testdata__CR__Limits_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]);
break;
case IMPLICATION_MATCH:
implication_.precondition = new Testdata__CR__Limits_template(*other_value.implication_.precondition);
implication_.implied_template = new Testdata__CR__Limits_template(*other_value.implication_.implied_template);
break;
case DYNAMIC_MATCH:
dyn_match = other_value.dyn_match;
dyn_match->ref_count++;
break;
default:
TTCN_error("Copying an uninitialized/unsupported template of type @HNBGW_Tests.Testdata_CR_Limits.");
break;
}
set_selection(other_value);
}

boolean Testdata__CR__Limits_template::match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy)
{
if (value_index >= 0) return ((const Testdata__CR__Limits_template*)template_ptr)->single_value.value_elements[template_index]->match((*(const Testdata__CR__Limits*)value_ptr)[value_index], legacy);
else return ((const Testdata__CR__Limits_template*)template_ptr)->single_value.value_elements[template_index]->is_any_or_omit();
}

Testdata__CR__Limits_template::Testdata__CR__Limits_template()
{
}

Testdata__CR__Limits_template::Testdata__CR__Limits_template(template_sel other_value)
 : Base_Record_Of_Template(other_value)
{
check_single_selection(other_value);
}

Testdata__CR__Limits_template::Testdata__CR__Limits_template(null_type)
 : Base_Record_Of_Template(SPECIFIC_VALUE)
{
single_value.n_elements = 0;
single_value.value_elements = NULL;
}

Testdata__CR__Limits_template::Testdata__CR__Limits_template(const Testdata__CR__Limits& other_value)
{
copy_value(other_value);
}

Testdata__CR__Limits_template::Testdata__CR__Limits_template(const OPTIONAL<Testdata__CR__Limits>& other_value)
{
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const Testdata__CR__Limits&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Creating a template of type @HNBGW_Tests.Testdata_CR_Limits from an unbound optional field.");
}
}

Testdata__CR__Limits_template::Testdata__CR__Limits_template(Testdata__CR__Limits_template* p_precondition, Testdata__CR__Limits_template* p_implied_template)
 : Base_Record_Of_Template(IMPLICATION_MATCH)
{
implication_.precondition = p_precondition;
implication_.implied_template = p_implied_template;
}

Testdata__CR__Limits_template::Testdata__CR__Limits_template(Dynamic_Match_Interface<Testdata__CR__Limits>* p_dyn_match)
 : Base_Record_Of_Template(DYNAMIC_MATCH)
{
dyn_match = new dynmatch_struct<Testdata__CR__Limits>;
dyn_match->ptr = p_dyn_match;
dyn_match->ref_count = 1;
}

Testdata__CR__Limits_template::Testdata__CR__Limits_template(const Testdata__CR__Limits_template& other_value)
 : Base_Record_Of_Template()
{
copy_template(other_value);
}

Testdata__CR__Limits_template::~Testdata__CR__Limits_template()
{
clean_up();
}

void Testdata__CR__Limits_template::clean_up()
{
switch (template_selection) {
case SPECIFIC_VALUE:
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
delete single_value.value_elements[elem_count];
free_pointers((void**)single_value.value_elements);
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
delete [] value_list.list_value;
break;
case IMPLICATION_MATCH:
delete implication_.precondition;
delete implication_.implied_template;
break;
case DYNAMIC_MATCH:
dyn_match->ref_count--;
if (dyn_match->ref_count == 0) {
delete dyn_match->ptr;
delete dyn_match;
}
break;
default:
break;
}
template_selection = UNINITIALIZED_TEMPLATE;
}

Testdata__CR__Limits_template& Testdata__CR__Limits_template::operator=(template_sel other_value)
{
check_single_selection(other_value);
clean_up();
set_selection(other_value);
return *this;
}

Testdata__CR__Limits_template& Testdata__CR__Limits_template::operator=(null_type)
{
clean_up();
set_selection(SPECIFIC_VALUE);
single_value.n_elements = 0;
single_value.value_elements = NULL;
return *this;
}

Testdata__CR__Limits_template& Testdata__CR__Limits_template::operator=(const Testdata__CR__Limits& other_value)
{
clean_up();
copy_value(other_value);
return *this;
}

Testdata__CR__Limits_template& Testdata__CR__Limits_template::operator=(const OPTIONAL<Testdata__CR__Limits>& other_value)
{
clean_up();
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const Testdata__CR__Limits&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Assignment of an unbound optional field to a template of type @HNBGW_Tests.Testdata_CR_Limits.");
}
return *this;
}

Testdata__CR__Limits_template& Testdata__CR__Limits_template::operator=(const Testdata__CR__Limits_template& other_value)
{
if (&other_value != this) {
clean_up();
copy_template(other_value);
}
return *this;
}

Testdata__CR__Limit_template& Testdata__CR__Limits_template::operator[](int index_value)
{
if (index_value < 0) TTCN_error("Accessing an element of a template for type @HNBGW_Tests.Testdata_CR_Limits using a negative index: %d.", index_value);
switch (template_selection)
{
  case SPECIFIC_VALUE:
    if(index_value < single_value.n_elements) break;
    // no break
  case OMIT_VALUE:
  case ANY_VALUE:
  case ANY_OR_OMIT:
  case UNINITIALIZED_TEMPLATE:
    set_size(index_value + 1);
    break;
  default:
    TTCN_error("Accessing an element of a non-specific template for type @HNBGW_Tests.Testdata_CR_Limits.");
    break;
}
return *single_value.value_elements[index_value];
}

Testdata__CR__Limit_template& Testdata__CR__Limits_template::operator[](const INTEGER& index_value)
{
index_value.must_bound("Using an unbound integer value for indexing a template of type @HNBGW_Tests.Testdata_CR_Limits.");
return (*this)[(int)index_value];
}

const Testdata__CR__Limit_template& Testdata__CR__Limits_template::operator[](int index_value) const
{
if (index_value < 0) TTCN_error("Accessing an element of a template for type @HNBGW_Tests.Testdata_CR_Limits using a negative index: %d.", index_value);
if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing an element of a non-specific template for type @HNBGW_Tests.Testdata_CR_Limits.");
if (index_value >= single_value.n_elements) TTCN_error("Index overflow in a template of type @HNBGW_Tests.Testdata_CR_Limits: The index is %d, but the template has only %d elements.", index_value, single_value.n_elements);
return *single_value.value_elements[index_value];
}

const Testdata__CR__Limit_template& Testdata__CR__Limits_template::operator[](const INTEGER& index_value) const
{
index_value.must_bound("Using an unbound integer value for indexing a template of type @HNBGW_Tests.Testdata_CR_Limits.");
return (*this)[(int)index_value];
}

void Testdata__CR__Limits_template::set_size(int new_size)
{
if (new_size < 0) TTCN_error("Internal error: Setting a negative size for a template of type @HNBGW_Tests.Testdata_CR_Limits.");
template_sel old_selection = template_selection;
if (old_selection != SPECIFIC_VALUE) {
clean_up();
set_selection(SPECIFIC_VALUE);
single_value.n_elements = 0;
single_value.value_elements = NULL;
}
if (new_size > single_value.n_elements) {
single_value.value_elements = (Testdata__CR__Limit_template**)reallocate_pointers((void**)single_value.value_elements, single_value.n_elements, new_size);
if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) {
for (int elem_count = single_value.n_elements; elem_count < new_size; elem_count++)
single_value.value_elements[elem_count] = new Testdata__CR__Limit_template(ANY_VALUE);
} else {
for (int elem_count = single_value.n_elements; elem_count < new_size; elem_count++)
single_value.value_elements[elem_count] = new Testdata__CR__Limit_template;
}
single_value.n_elements = new_size;
} else if (new_size < single_value.n_elements) {
for (int elem_count = new_size; elem_count < single_value.n_elements; elem_count++)
delete single_value.value_elements[elem_count];
single_value.value_elements = (Testdata__CR__Limit_template**)reallocate_pointers((void**)single_value.value_elements, single_value.n_elements, new_size);
single_value.n_elements = new_size;
}
}

int Testdata__CR__Limits_template::n_elem() const
{
  switch (template_selection) {
  case SPECIFIC_VALUE:
    return single_value.n_elements;
    break;
  case VALUE_LIST:
    return value_list.n_values;
    break;
  default:
    TTCN_error("Performing n_elem");
  }
}

int Testdata__CR__Limits_template::size_of(boolean is_size) const
{
const char* op_name = is_size ? "size" : "length";
int min_size;
boolean has_any_or_none;
if (is_ifpresent) TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limits which has an ifpresent attribute.", op_name);
switch (template_selection)
{
case SPECIFIC_VALUE: {
  min_size = 0;
  has_any_or_none = FALSE;
  int elem_count = single_value.n_elements;
  if (!is_size) { while (elem_count>0 && !single_value.value_elements[elem_count-1]->is_bound()) elem_count--; }
  for (int i=0; i<elem_count; i++) {
    switch (single_value.value_elements[i]->get_selection()) {
    case OMIT_VALUE:
      TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limits containing omit element.", op_name);
    case ANY_OR_OMIT:
      has_any_or_none = TRUE;
      break;
    default:
      min_size++;
      break;
    }
  }
} break;
case OMIT_VALUE:
  TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limits containing omit value.", op_name);
case ANY_VALUE:
case ANY_OR_OMIT:
  min_size = 0;
  has_any_or_none = TRUE;
  break;
case VALUE_LIST:
{
  if (value_list.n_values<1)
    TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limits containing an empty list.", op_name);
  int item_size = value_list.list_value[0].size_of(is_size);
  for (unsigned int i = 1; i < value_list.n_values; i++) {
    if (value_list.list_value[i].size_of(is_size)!=item_size)
      TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limits containing a value list with different sizes.", op_name);
  }
  min_size = item_size;
  has_any_or_none = FALSE;
  break;
}
case COMPLEMENTED_LIST:
  TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.Testdata_CR_Limits containing complemented list.", op_name);
default:
  TTCN_error("Performing %sof() operation on an uninitialized/unsupported template of type @HNBGW_Tests.Testdata_CR_Limits.", op_name);
}
return check_section_is_single(min_size, has_any_or_none, op_name, "a", "template of type @HNBGW_Tests.Testdata_CR_Limits");
}

boolean Testdata__CR__Limits_template::match(const Testdata__CR__Limits& other_value, boolean legacy) const
{
if (!other_value.is_bound()) return FALSE;
int value_length = other_value.size_of();
if (!match_length(value_length)) return FALSE;
switch (template_selection) {
case SPECIFIC_VALUE:
return match_record_of(&other_value, value_length, this, single_value.n_elements, match_function_specific, legacy);
case OMIT_VALUE:
return FALSE;
case ANY_VALUE:
case ANY_OR_OMIT:
return TRUE;
case VALUE_LIST:
case COMPLEMENTED_LIST:
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST;
return template_selection == COMPLEMENTED_LIST;
case CONJUNCTION_MATCH:
for (unsigned int i = 0; i < value_list.n_values; i++) {
if (!value_list.list_value[i].match(other_value)) {
return FALSE;
}
}
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value);
case DYNAMIC_MATCH:
return dyn_match->ptr->match(other_value);
default:
TTCN_error("Matching with an uninitialized/unsupported template of type @HNBGW_Tests.Testdata_CR_Limits.");
}
return FALSE;
}

boolean Testdata__CR__Limits_template::is_value() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE;
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
if (!single_value.value_elements[elem_count]->is_value()) return FALSE;
return TRUE;
}

Testdata__CR__Limits Testdata__CR__Limits_template::valueof() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of type @HNBGW_Tests.Testdata_CR_Limits.");
Testdata__CR__Limits ret_val;
ret_val.set_size(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
if (single_value.value_elements[elem_count]->is_bound()) {
ret_val[elem_count] = single_value.value_elements[elem_count]->valueof();
}
return ret_val;
}

Testdata__CR__Limits Testdata__CR__Limits_template::substr(int index, int returncount) const
{
if (!is_value()) TTCN_error("The first argument of function substr() is a template with non-specific value.");
return valueof().substr(index, returncount);
}

Testdata__CR__Limits Testdata__CR__Limits_template::replace(int index, int len, const Testdata__CR__Limits_template& repl) const
{
if (!is_value()) TTCN_error("The first argument of function replace() is a template with non-specific value.");
if (!repl.is_value()) TTCN_error("The fourth argument of function replace() is a template with non-specific value.");
return valueof().replace(index, len, repl.valueof());
}

Testdata__CR__Limits Testdata__CR__Limits_template::replace(int index, int len, const Testdata__CR__Limits& repl) const
{
if (!is_value()) TTCN_error("The first argument of function replace() is a template with non-specific value.");
return valueof().replace(index, len, repl);
}

void Testdata__CR__Limits_template::set_type(template_sel template_type, unsigned int list_length)
{
clean_up();
switch (template_type) {
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
value_list.n_values = list_length;
value_list.list_value = new Testdata__CR__Limits_template[list_length];
break;
default:
TTCN_error("Internal error: Setting an invalid type for a template of type @HNBGW_Tests.Testdata_CR_Limits.");
}
set_selection(template_type);
}

Testdata__CR__Limits_template& Testdata__CR__Limits_template::list_item(unsigned int list_index)
{
if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST && template_selection != CONJUNCTION_MATCH) TTCN_error("Internal error: Accessing a list element of a non-list template of type @HNBGW_Tests.Testdata_CR_Limits.");
if (list_index >= value_list.n_values) TTCN_error("Internal error: Index overflow in a value list template of type @HNBGW_Tests.Testdata_CR_Limits.");
return value_list.list_value[list_index];
}

void Testdata__CR__Limits_template::log() const
{
switch (template_selection) {
case SPECIFIC_VALUE:
if (single_value.n_elements > 0) {
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
if (permutation_starts_at(elem_count)) TTCN_Logger::log_event_str("permutation(");
single_value.value_elements[elem_count]->log();
if (permutation_ends_at(elem_count)) TTCN_Logger::log_char(')');
}
TTCN_Logger::log_event_str(" }");
} else TTCN_Logger::log_event_str("{ }");
break;
case COMPLEMENTED_LIST:
TTCN_Logger::log_event_str("complement");
case CONJUNCTION_MATCH:
if (template_selection == CONJUNCTION_MATCH) {
TTCN_Logger::log_event_str("conjunct");
}
case VALUE_LIST:
TTCN_Logger::log_char('(');
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) {
if (list_count > 0) TTCN_Logger::log_event_str(", ");
value_list.list_value[list_count].log();
}
TTCN_Logger::log_char(')');
break;
case IMPLICATION_MATCH:
implication_.precondition->log();
TTCN_Logger::log_event_str(" implies ");
implication_.implied_template->log();
break;
case DYNAMIC_MATCH:
TTCN_Logger::log_event_str("@dynamic template");
break;
default:
log_generic();
}
log_restricted();
log_ifpresent();
}

void Testdata__CR__Limits_template::log_match(const Testdata__CR__Limits& match_value, boolean legacy) const
{
if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){
if(match(match_value, legacy)){
TTCN_Logger::print_logmatch_buffer();
TTCN_Logger::log_event_str(" matched");
}else{
if (template_selection == SPECIFIC_VALUE && single_value.n_elements > 0 && get_number_of_permutations() == 0 && single_value.n_elements == match_value.size_of()) {
size_t previous_size = TTCN_Logger::get_logmatch_buffer_len();
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if(!single_value.value_elements[elem_count]->match(match_value[elem_count], legacy)){
TTCN_Logger::log_logmatch_info("[%d]", elem_count);
single_value.value_elements[elem_count]->log_match(match_value[elem_count], legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
}
log_match_length(single_value.n_elements);
} else {
TTCN_Logger::print_logmatch_buffer();
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
TTCN_Logger::log_event_str(" unmatched");
}
}
return;
}
if (template_selection == SPECIFIC_VALUE && single_value.n_elements > 0 && get_number_of_permutations() == 0 && single_value.n_elements == match_value.size_of()) {
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
single_value.value_elements[elem_count]->log_match(match_value[elem_count], legacy);
}
TTCN_Logger::log_event_str(" }");
log_match_length(single_value.n_elements);
} else {
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched");
else TTCN_Logger::log_event_str(" unmatched");
}
}

void Testdata__CR__Limits_template::encode_text(Text_Buf& text_buf) const
{
encode_text_permutation(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
text_buf.push_int(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
single_value.value_elements[elem_count]->encode_text(text_buf);
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
text_buf.push_int(value_list.n_values);
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].encode_text(text_buf);
break;
default:
TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @HNBGW_Tests.Testdata_CR_Limits.");
}
}

void Testdata__CR__Limits_template::decode_text(Text_Buf& text_buf)
{
clean_up();
decode_text_permutation(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value.n_elements = text_buf.pull_int().get_val();
if (single_value.n_elements < 0) TTCN_error("Text decoder: Negative size was received for a template of type @HNBGW_Tests.Testdata_CR_Limits.");
single_value.value_elements = (Testdata__CR__Limit_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
single_value.value_elements[elem_count] = new Testdata__CR__Limit_template;
single_value.value_elements[elem_count]->decode_text(text_buf);
}
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
value_list.n_values = text_buf.pull_int().get_val();
value_list.list_value = new Testdata__CR__Limits_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].decode_text(text_buf);
break;
default:
TTCN_error("Text decoder: An unknown/unsupported selection was received for a template of type @HNBGW_Tests.Testdata_CR_Limits.");
}
}

boolean Testdata__CR__Limits_template::is_present(boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE;
return !match_omit(legacy);
}

boolean Testdata__CR__Limits_template::match_omit(boolean legacy) const
{
if (is_ifpresent) return TRUE;
switch (template_selection) {
case OMIT_VALUE:
case ANY_OR_OMIT:
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match_omit() || implication_.implied_template->match_omit();
case VALUE_LIST:
case COMPLEMENTED_LIST:
if (legacy) {
for (unsigned int i=0; i<value_list.n_values; i++)
if (value_list.list_value[i].match_omit())
return template_selection==VALUE_LIST;
return template_selection==COMPLEMENTED_LIST;
} // else fall through
default:
return FALSE;
}
return FALSE;
}

void Testdata__CR__Limits_template::set_implicit_omit()
{
if (template_selection != SPECIFIC_VALUE) return;
for (int i = 0; i < single_value.n_elements; i++) {
if (single_value.value_elements[i] != NULL) single_value.value_elements[i]->set_implicit_omit();
}
}

void Testdata__CR__Limits_template::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_TEMPLATE|Module_Param::BC_LIST, "record of template");
  switch (param.get_type()) {
  case Module_Param::MP_Omit:
    *this = OMIT_VALUE;
    break;
  case Module_Param::MP_Any:
    *this = ANY_VALUE;
    break;
  case Module_Param::MP_AnyOrNone:
    *this = ANY_OR_OMIT;
    break;
  case Module_Param::MP_List_Template:
  case Module_Param::MP_ComplementList_Template:
  case Module_Param::MP_ConjunctList_Template: {
    Testdata__CR__Limits_template temp;
    temp.set_type(param.get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (param.get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), param.get_size());
    for (size_t p_i=0; p_i<param.get_size(); p_i++) {
      temp.list_item(p_i).set_param(*param.get_elem(p_i));
    }
    *this = temp;
    break; }
  case Module_Param::MP_Indexed_List:
    if (template_selection!=SPECIFIC_VALUE) set_size(0);
    for (size_t p_i=0; p_i<param.get_size(); ++p_i) {
      (*this)[(int)(param.get_elem(p_i)->get_id()->get_index())].set_param(*param.get_elem(p_i));
    }
    break;
  case Module_Param::MP_Value_List: {
    set_size(param.get_size());
    int curr_idx = 0;
    for (size_t p_i=0; p_i<param.get_size(); ++p_i) {
      switch (param.get_elem(p_i)->get_type()) {
      case Module_Param::MP_NotUsed:
        curr_idx++;
        break;
      case Module_Param::MP_Permutation_Template: {
        int perm_start_idx = curr_idx;
        Module_Param* param_i = param.get_elem(p_i);
        for (size_t perm_i=0; perm_i<param_i->get_size(); perm_i++) {
          (*this)[curr_idx].set_param(*(param_i->get_elem(perm_i)));
          curr_idx++;
        }
        int perm_end_idx = curr_idx - 1;
        add_permutation(perm_start_idx, perm_end_idx);
      } break;
      default:
        (*this)[curr_idx].set_param(*param.get_elem(p_i));
        curr_idx++;
      }
    }
  } break;
  case Module_Param::MP_Implication_Template: {
    Testdata__CR__Limits_template* precondition = new Testdata__CR__Limits_template;
    precondition->set_param(*param.get_elem(0));
    Testdata__CR__Limits_template* implied_template = new Testdata__CR__Limits_template;
    implied_template->set_param(*param.get_elem(1));
    *this = Testdata__CR__Limits_template(precondition, implied_template);
  } break;
  default:
    param.type_error("record of template", "@HNBGW_Tests.Testdata_CR_Limits");
  }
  is_ifpresent = param.get_ifpresent();
  set_length_range(param);
}

void Testdata__CR__Limits_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return;
switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) {
case TR_OMIT:
if (template_selection==OMIT_VALUE) return;
case TR_VALUE:
if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break;
for (int i=0; i<single_value.n_elements; i++) single_value.value_elements[i]->check_restriction(t_res, t_name ? t_name : "@HNBGW_Tests.Testdata_CR_Limits");
return;
case TR_PRESENT:
if (!match_omit(legacy)) return;
break;
default:
return;
}
TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@HNBGW_Tests.Testdata_CR_Limits");
}

boolean Testdata__CR__Limits_template::get_istemplate_kind(const char* type) const {
if (!strcmp(type, "AnyElement")) {
  if (template_selection != SPECIFIC_VALUE) {
    return FALSE;
  }
  for (int i = 0; i < single_value.n_elements; i++) {
    if (single_value.value_elements[i]->get_selection() == ANY_VALUE) {
      return TRUE;
    }
  }
  return FALSE;
} else if (!strcmp(type, "AnyElementsOrNone")) {
  if (template_selection != SPECIFIC_VALUE) {
    return FALSE;
  }
  for (int i = 0; i < single_value.n_elements; i++) {
    if (single_value.value_elements[i]->get_selection() == ANY_OR_OMIT) {
      return TRUE;
    }
  }
  return FALSE;
} else if (!strcmp(type, "permutation")) {
  return number_of_permutations;
} else if (!strcmp(type, "length")) {
  return length_restriction_type != NO_LENGTH_RESTRICTION;
} else {
  return Base_Template::get_istemplate_kind(type);
}
}
Compl3Type::Compl3Type()
{
enum_value = UNBOUND_VALUE;
}

Compl3Type::Compl3Type(int other_value)
{
if (!is_valid_enum(other_value)) TTCN_error("Initializing a variable of enumerated type @HNBGW_Tests.Compl3Type with invalid numeric value %d.", other_value);
enum_value = (enum_type)other_value;
}

Compl3Type::Compl3Type(enum_type other_value)
{
enum_value = other_value;
}

Compl3Type::Compl3Type(const Compl3Type& other_value)
: Base_Type()
{
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("Copying an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
enum_value = other_value.enum_value;
}

Compl3Type& Compl3Type::operator=(int other_value)
{
if (!is_valid_enum(other_value)) TTCN_error("Assigning unknown numeric value %d to a variable of enumerated type @HNBGW_Tests.Compl3Type.", other_value);
enum_value = (enum_type)other_value;
return *this;
}

Compl3Type& Compl3Type::operator=(enum_type other_value)
{
enum_value = other_value;
return *this;
}

Compl3Type& Compl3Type::operator=(const Compl3Type& other_value)
{
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("Assignment of an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
enum_value = other_value.enum_value;
return *this;
}

boolean Compl3Type::operator==(int other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
if (!is_valid_enum(other_value)) TTCN_error("The right operand of enumerated type @HNBGW_Tests.Compl3Type comparison is an unknown numeric value %d", other_value);
return enum_value == other_value;
}

boolean Compl3Type::operator==(enum_type other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
return enum_value == other_value;
}

boolean Compl3Type::operator==(const Compl3Type& other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("The right operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
return enum_value == other_value.enum_value;
}

boolean Compl3Type::operator<(int other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
if (!is_valid_enum(other_value)) TTCN_error("The right operand of enumerated type @HNBGW_Tests.Compl3Type comparison is an unknown numeric value %d", other_value);
return enum_value < other_value;
}

boolean Compl3Type::operator<(enum_type other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
return enum_value < other_value;
}

boolean Compl3Type::operator<(const Compl3Type& other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("The right operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
return enum_value < other_value.enum_value;
}

boolean Compl3Type::operator>(int other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
if (!is_valid_enum(other_value)) TTCN_error("The right operand of enumerated type @HNBGW_Tests.Compl3Type comparison is an unknown numeric value %d", other_value);
return enum_value > other_value;
}

boolean Compl3Type::operator>(enum_type other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
return enum_value > other_value;
}

boolean Compl3Type::operator>(const Compl3Type& other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("The right operand of comparison is an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
return enum_value > other_value.enum_value;
}

const char *Compl3Type::enum_to_str(enum_type enum_par)
{
switch (enum_par) {
case LU: return "LU";
case CMSERV: return "CMSERV";
case PAGRESP: return "PAGRESP";
case IMSIDETACH: return "IMSIDETACH";
case ATTACHREQ: return "ATTACHREQ";
case RAUREQ: return "RAUREQ";
case DETREQ: return "DETREQ";
default:
return "<unknown>";
}
}

Compl3Type::enum_type Compl3Type::str_to_enum(const char *str_par, const int* int_par, const int* int_par2)
{
if (int_par == NULL && int_par2 == NULL) {
if (!strcmp(str_par, "LU")) return LU;
if (!strcmp(str_par, "CMSERV")) return CMSERV;
if (!strcmp(str_par, "PAGRESP")) return PAGRESP;
if (!strcmp(str_par, "IMSIDETACH")) return IMSIDETACH;
if (!strcmp(str_par, "ATTACHREQ")) return ATTACHREQ;
if (!strcmp(str_par, "RAUREQ")) return RAUREQ;
if (!strcmp(str_par, "DETREQ")) return DETREQ;
}
return UNKNOWN_VALUE;
}

boolean Compl3Type::is_valid_enum(int int_par)
{
switch (int_par) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
return TRUE;
default:
return FALSE;
}
}

int Compl3Type::enum2int(enum_type enum_par)
{
if (enum_par==UNBOUND_VALUE || enum_par==UNKNOWN_VALUE) TTCN_error("The argument of function enum2int() is an %s value of enumerated type @HNBGW_Tests.Compl3Type.", enum_par==UNBOUND_VALUE?"unbound":"invalid");
return enum_par;
}

int Compl3Type::enum2int(const Compl3Type& enum_par)
{
if (enum_par.enum_value==UNBOUND_VALUE || enum_par.enum_value==UNKNOWN_VALUE) TTCN_error("The argument of function enum2int() is an %s value of enumerated type @HNBGW_Tests.Compl3Type.", enum_par==UNBOUND_VALUE?"unbound":"invalid");
return enum_par.enum_value;
}

void Compl3Type::int2enum(int int_val)
{
if (!is_valid_enum(int_val)) TTCN_error("Assigning invalid numeric value %d to a variable of enumerated type @HNBGW_Tests.Compl3Type.", int_val);
enum_value = (enum_type)int_val;
}

Compl3Type::operator Compl3Type::enum_type() const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("Using the value of an unbound variable of enumerated type @HNBGW_Tests.Compl3Type.");
return enum_value;
}

void Compl3Type::log() const
{
if (enum_value != UNBOUND_VALUE) TTCN_Logger::log_event_enum(enum_to_str(enum_value), enum_value);
else TTCN_Logger::log_event_unbound();
}

void Compl3Type::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_VALUE, "enumerated value");
  if (param.get_type()!=Module_Param::MP_Enumerated) param.type_error("enumerated value", "@HNBGW_Tests.Compl3Type");
  enum_value = str_to_enum(param.get_enumerated(), param.get_enumerated_value());
  if (!is_valid_enum(enum_value)) {
    param.error("Invalid enumerated value for type @HNBGW_Tests.Compl3Type.");
  }
}

void Compl3Type::encode_text(Text_Buf& text_buf) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("Text encoder: Encoding an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
text_buf.push_int(enum_value);
}

void Compl3Type::decode_text(Text_Buf& text_buf)
{
enum_value = (enum_type)text_buf.pull_int().get_val();
if (!is_valid_enum(enum_value)) TTCN_error("Text decoder: Unknown numeric value %d was received for enumerated type @HNBGW_Tests.Compl3Type.", enum_value);
}

void Compl3Type_template::copy_template(const Compl3Type_template& other_value)
{
set_selection(other_value);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value = other_value.single_value;
break;
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
value_list.n_values = other_value.value_list.n_values;
value_list.list_value = new Compl3Type_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]);
break;
case IMPLICATION_MATCH:
implication_.precondition = new Compl3Type_template(*other_value.implication_.precondition);
implication_.implied_template = new Compl3Type_template(*other_value.implication_.implied_template);
break;
case DYNAMIC_MATCH:
dyn_match = other_value.dyn_match;
dyn_match->ref_count++;
break;
default:
TTCN_error("Copying an uninitialized/unsupported template of enumerated type @HNBGW_Tests.Compl3Type.");
}
}

Compl3Type_template::Compl3Type_template()
{
}

Compl3Type_template::Compl3Type_template(template_sel other_value)
 : Base_Template(other_value)
{
check_single_selection(other_value);
}

Compl3Type_template::Compl3Type_template(int other_value)
 : Base_Template(SPECIFIC_VALUE)
{
if (!Compl3Type::is_valid_enum(other_value)) TTCN_error("Initializing a template of enumerated type @HNBGW_Tests.Compl3Type with unknown numeric value %d.", other_value);
single_value = (Compl3Type::enum_type)other_value;
}

Compl3Type_template::Compl3Type_template(Compl3Type::enum_type other_value)
 : Base_Template(SPECIFIC_VALUE)
{
single_value = other_value;
}

Compl3Type_template::Compl3Type_template(const Compl3Type& other_value)
 : Base_Template(SPECIFIC_VALUE)
{
if (other_value.enum_value == Compl3Type::UNBOUND_VALUE) TTCN_error("Creating a template from an unbound value of enumerated type @HNBGW_Tests.Compl3Type.");
single_value = other_value.enum_value;
}

Compl3Type_template::Compl3Type_template(const OPTIONAL<Compl3Type>& other_value)
{
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
set_selection(SPECIFIC_VALUE);
single_value = (Compl3Type::enum_type)(const Compl3Type&)other_value;
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Creating a template of enumerated type @HNBGW_Tests.Compl3Type from an unbound optional field.");
}
}

Compl3Type_template::Compl3Type_template(Compl3Type_template* p_precondition, Compl3Type_template* p_implied_template)
 : Base_Template(IMPLICATION_MATCH)
{
implication_.precondition = p_precondition;
implication_.implied_template = p_implied_template;
}

Compl3Type_template::Compl3Type_template(Dynamic_Match_Interface<Compl3Type>* p_dyn_match)
 : Base_Template(DYNAMIC_MATCH)
{
dyn_match = new dynmatch_struct<Compl3Type>;
dyn_match->ptr = p_dyn_match;
dyn_match->ref_count = 1;
}

Compl3Type_template::Compl3Type_template(const Compl3Type_template& other_value)
 : Base_Template()
{
copy_template(other_value);
}

Compl3Type_template::~Compl3Type_template()
{
clean_up();
}

boolean Compl3Type_template::is_bound() const
{
if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE;
return TRUE;
}

boolean Compl3Type_template::is_value() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE;
return single_value != Compl3Type::UNBOUND_VALUE;
}

void Compl3Type_template::clean_up()
{
switch (template_selection) {
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
delete [] value_list.list_value;
break;
case IMPLICATION_MATCH:
delete implication_.precondition;
delete implication_.implied_template;
break;
case DYNAMIC_MATCH:
dyn_match->ref_count--;
if (dyn_match->ref_count == 0) {
delete dyn_match->ptr;
delete dyn_match;
}
break;
default:
break;
}
template_selection = UNINITIALIZED_TEMPLATE;
}

Compl3Type_template& Compl3Type_template::operator=(template_sel other_value)
{
check_single_selection(other_value);
clean_up();
set_selection(other_value);
return *this;
}

Compl3Type_template& Compl3Type_template::operator=(int other_value)
{
if (!Compl3Type::is_valid_enum(other_value)) TTCN_warning("Assigning unknown numeric value %d to a template of enumerated type @HNBGW_Tests.Compl3Type.", other_value);
clean_up();
set_selection(SPECIFIC_VALUE);
single_value = (Compl3Type::enum_type)other_value;
return *this;
}

Compl3Type_template& Compl3Type_template::operator=(Compl3Type::enum_type other_value)
{
clean_up();
set_selection(SPECIFIC_VALUE);
single_value = other_value;
return *this;
}

Compl3Type_template& Compl3Type_template::operator=(const Compl3Type& other_value)
{
if (other_value.enum_value == Compl3Type::UNBOUND_VALUE) TTCN_error("Assignment of an unbound value of enumerated type @HNBGW_Tests.Compl3Type to a template.");
clean_up();
set_selection(SPECIFIC_VALUE);
single_value = other_value.enum_value;
return *this;
}

Compl3Type_template& Compl3Type_template::operator=(const OPTIONAL<Compl3Type>& other_value)
{
clean_up();
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
set_selection(SPECIFIC_VALUE);
single_value = (Compl3Type::enum_type)(const Compl3Type&)other_value;
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Assignment of an unbound optional field to a template of enumerated type @HNBGW_Tests.Compl3Type.");
}
return *this;
}

Compl3Type_template& Compl3Type_template::operator=(const Compl3Type_template& other_value)
{
if (&other_value != this) {
clean_up();
copy_template(other_value);
}
return *this;
}

boolean Compl3Type_template::match(Compl3Type::enum_type other_value, boolean) const
{
switch (template_selection) {
case SPECIFIC_VALUE:
return single_value == other_value;
case OMIT_VALUE:
return FALSE;
case ANY_VALUE:
case ANY_OR_OMIT:
return TRUE;
case VALUE_LIST:
case COMPLEMENTED_LIST:
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
if (value_list.list_value[list_count].match(other_value)) return template_selection == VALUE_LIST;
return template_selection == COMPLEMENTED_LIST;
case CONJUNCTION_MATCH:
for (unsigned int i = 0; i < value_list.n_values; i++) {
if (!value_list.list_value[i].match(other_value)) {
return FALSE;
}
}
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value);
case DYNAMIC_MATCH:
return dyn_match->ptr->match(other_value);
default:
TTCN_error("Matching an uninitialized/unsupported template of enumerated type @HNBGW_Tests.Compl3Type.");
}
return FALSE;
}

boolean Compl3Type_template::match(const Compl3Type& other_value, boolean) const
{
if (other_value.enum_value == Compl3Type::UNBOUND_VALUE) TTCN_error("Matching a template of enumerated type @HNBGW_Tests.Compl3Type with an unbound value.");
return match(other_value.enum_value);
}

Compl3Type::enum_type Compl3Type_template::valueof() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of enumerated type @HNBGW_Tests.Compl3Type.");
return single_value;
}

void Compl3Type_template::set_type(template_sel template_type, unsigned int list_length)
{
clean_up();
switch (template_type) {
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
set_selection(template_type);
value_list.n_values = list_length;
value_list.list_value = new Compl3Type_template[list_length];
break;
default:
TTCN_error("Setting an invalid type for a template of enumerated type @HNBGW_Tests.Compl3Type.");
}
}

Compl3Type_template& Compl3Type_template::list_item(unsigned int list_index)
{
if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST && template_selection != CONJUNCTION_MATCH) TTCN_error("Accessing a list element in a non-list template of enumerated type @HNBGW_Tests.Compl3Type.");
if (list_index >= value_list.n_values) TTCN_error("Index overflow in a value list template of enumerated type @HNBGW_Tests.Compl3Type.");
return value_list.list_value[list_index];
}

void Compl3Type_template::log() const
{
switch (template_selection) {
case SPECIFIC_VALUE:
TTCN_Logger::log_event_enum(Compl3Type::enum_to_str(single_value), single_value);
break;
case COMPLEMENTED_LIST:
TTCN_Logger::log_event_str("complement");
case CONJUNCTION_MATCH:
if (template_selection == CONJUNCTION_MATCH) {
TTCN_Logger::log_event_str("conjunct");
}
case VALUE_LIST:
TTCN_Logger::log_char('(');
for (unsigned int elem_count = 0; elem_count < value_list.n_values; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
value_list.list_value[elem_count].log();
}
TTCN_Logger::log_char(')');
break;
case IMPLICATION_MATCH:
implication_.precondition->log();
TTCN_Logger::log_event_str(" implies ");
implication_.implied_template->log();
break;
case DYNAMIC_MATCH:
TTCN_Logger::log_event_str("@dynamic template");
break;
default:
log_generic();
}
log_ifpresent();
}

void Compl3Type_template::log_match(const Compl3Type& match_value, boolean) const
{
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
if (match(match_value)) TTCN_Logger::log_event_str(" matched");
else TTCN_Logger::log_event_str(" unmatched");
}

void Compl3Type_template::encode_text(Text_Buf& text_buf) const
{
encode_text_base(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
text_buf.push_int(single_value);
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
text_buf.push_int(value_list.n_values);
for (unsigned int elem_count = 0; elem_count < value_list.n_values; elem_count++)
value_list.list_value[elem_count].encode_text(text_buf);
break;
default:
TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of enumerated type @HNBGW_Tests.Compl3Type.");
}
}

void Compl3Type_template::decode_text(Text_Buf& text_buf)
{
clean_up();
decode_text_base(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value = (Compl3Type::enum_type)text_buf.pull_int().get_val();
if (!Compl3Type::is_valid_enum(single_value)) TTCN_error("Text decoder: Unknown numeric value %d was received for a template of enumerated type @HNBGW_Tests.Compl3Type.", single_value);
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
value_list.n_values = text_buf.pull_int().get_val();
value_list.list_value = new Compl3Type_template[value_list.n_values];
for (unsigned int elem_count = 0; elem_count < value_list.n_values; elem_count++)
value_list.list_value[elem_count].decode_text(text_buf);
break;
default:
TTCN_error("Text decoder: An unknown/unsupported selection was received for a template of enumerated type @HNBGW_Tests.Compl3Type.");
}
}

boolean Compl3Type_template::is_present(boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE;
return !match_omit(legacy);
}

boolean Compl3Type_template::match_omit(boolean legacy) const
{
if (is_ifpresent) return TRUE;
switch (template_selection) {
case OMIT_VALUE:
case ANY_OR_OMIT:
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match_omit() || implication_.implied_template->match_omit();
case VALUE_LIST:
case COMPLEMENTED_LIST:
if (legacy) {
for (unsigned int i=0; i<value_list.n_values; i++)
if (value_list.list_value[i].match_omit())
return template_selection==VALUE_LIST;
return template_selection==COMPLEMENTED_LIST;
} // else fall through
default:
return FALSE;
}
return FALSE;
}

void Compl3Type_template::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_TEMPLATE, "enumerated template");
  Module_Param_Ptr m_p = &param;
  switch (m_p->get_type()) {
  case Module_Param::MP_Omit:
    *this = OMIT_VALUE;
    break;
  case Module_Param::MP_Any:
    *this = ANY_VALUE;
    break;
  case Module_Param::MP_AnyOrNone:
    *this = ANY_OR_OMIT;
    break;
  case Module_Param::MP_List_Template:
  case Module_Param::MP_ComplementList_Template:
  case Module_Param::MP_ConjunctList_Template: {
    Compl3Type_template new_temp;
    new_temp.set_type(m_p->get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (m_p->get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), m_p->get_size());
    for (size_t p_i=0; p_i<m_p->get_size(); p_i++) {
      new_temp.list_item(p_i).set_param(*m_p->get_elem(p_i));
    }
    *this = new_temp;
    break; }
  case Module_Param::MP_Enumerated: {
    Compl3Type::enum_type enum_val = Compl3Type::str_to_enum(m_p->get_enumerated(), m_p->get_enumerated_value());
    if (!Compl3Type::is_valid_enum(enum_val)) {
      param.error("Invalid enumerated value for type @HNBGW_Tests.Compl3Type.");
    }
    *this = enum_val;
  } break;
  case Module_Param::MP_Implication_Template: {
    Compl3Type_template* precondition = new Compl3Type_template;
    precondition->set_param(*m_p->get_elem(0));
    Compl3Type_template* implied_template = new Compl3Type_template;
    implied_template->set_param(*m_p->get_elem(1));
    *this = Compl3Type_template(precondition, implied_template);
  } break;
  default:
    param.type_error("enumerated template", "@HNBGW_Tests.Compl3Type");
  }
  is_ifpresent = param.get_ifpresent();
}

void Compl3Type_template::check_restriction(template_res t_res, const char* t_name,
boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return;
switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) {
case TR_VALUE:
if (!is_ifpresent && template_selection==SPECIFIC_VALUE) return;
break;
case TR_OMIT:
if (!is_ifpresent && (template_selection==OMIT_VALUE || template_selection==SPECIFIC_VALUE)) return;
break;
case TR_PRESENT:
if (!match_omit(legacy)) return;
break;
default:
return;
}
TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@HNBGW_Tests.Compl3Type");
}


const Compl3Type ro__Compl3Type::UNBOUND_ELEM;
ro__Compl3Type::ro__Compl3Type()
{
val_ptr = NULL;
}

ro__Compl3Type::ro__Compl3Type(null_type)
{
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
}

ro__Compl3Type::ro__Compl3Type(const ro__Compl3Type& other_value)
{
if (!other_value.is_bound()) TTCN_error("Copying an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
val_ptr = other_value.val_ptr;
val_ptr->ref_count++;
}

ro__Compl3Type::~ro__Compl3Type()
{
clean_up();
if (val_ptr != NULL) val_ptr = NULL;
}

void ro__Compl3Type::clean_up()
{
if (val_ptr != NULL) {
if (val_ptr->ref_count > 1) {
val_ptr->ref_count--;
val_ptr = NULL;
}
else if (val_ptr->ref_count == 1) {
for (int elem_count = 0; elem_count < val_ptr->n_elements;
elem_count++)
if (val_ptr->value_elements[elem_count] != NULL)
delete val_ptr->value_elements[elem_count];
free_pointers((void**)val_ptr->value_elements);
delete val_ptr;
val_ptr = NULL;
}
else
TTCN_error("Internal error: Invalid reference counter in a record of/set of value.");
}
}

ro__Compl3Type& ro__Compl3Type::operator=(null_type)
{
clean_up();
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
return *this;
}

ro__Compl3Type& ro__Compl3Type::operator=(const ro__Compl3Type& other_value)
{
if (other_value.val_ptr == NULL) TTCN_error("Assigning an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
if (this != &other_value) {
clean_up();
val_ptr = other_value.val_ptr;
val_ptr->ref_count++;
}
return *this;
}

boolean ro__Compl3Type::operator==(null_type) const
{
if (val_ptr == NULL)
TTCN_error("The left operand of comparison is an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
return val_ptr->n_elements == 0 ;
}

boolean ro__Compl3Type::operator==(const ro__Compl3Type& other_value) const
{
if (val_ptr == NULL) TTCN_error("The left operand of comparison is an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
if (val_ptr == other_value.val_ptr) return TRUE;
if (val_ptr->n_elements != (other_value.val_ptr)->n_elements)
return FALSE;
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++){
if (val_ptr->value_elements[elem_count] != NULL){
if ((other_value.val_ptr)->value_elements[elem_count] != NULL){
  if (*val_ptr->value_elements[elem_count] != *(other_value.val_ptr)->value_elements[elem_count]) return FALSE;
} else return FALSE;
} else {
if ((other_value.val_ptr)->value_elements[elem_count] != NULL) return FALSE;
}
}
return TRUE;
}

Compl3Type& ro__Compl3Type::operator[](int index_value)
{
if (index_value < 0) TTCN_error("Accessing an element of type @HNBGW_Tests.ro_Compl3Type using a negative index: %d.", index_value);
if (val_ptr == NULL) {
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
} else if (val_ptr->ref_count > 1) {
struct recordof_setof_struct *new_val_ptr = new recordof_setof_struct;
new_val_ptr->ref_count = 1;
new_val_ptr->n_elements = (index_value >= val_ptr->n_elements) ? index_value + 1 : val_ptr->n_elements;
new_val_ptr->value_elements = (Compl3Type**)allocate_pointers(new_val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++){
if (val_ptr->value_elements[elem_count] != NULL){
new_val_ptr->value_elements[elem_count] = new Compl3Type(*(val_ptr->value_elements[elem_count]));
}
}
clean_up();
val_ptr = new_val_ptr;
}
if (index_value >= val_ptr->n_elements) set_size(index_value + 1);
if (val_ptr->value_elements[index_value] == NULL) {
val_ptr->value_elements[index_value] = new Compl3Type;
}
return *val_ptr->value_elements[index_value];
}

Compl3Type& ro__Compl3Type::operator[](const INTEGER& index_value)
{
index_value.must_bound("Using an unbound integer value for indexing a value of type @HNBGW_Tests.ro_Compl3Type.");
return (*this)[(int)index_value];
}

const Compl3Type& ro__Compl3Type::operator[](int index_value) const
{
if (val_ptr == NULL)
TTCN_error("Accessing an element in an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
if (index_value < 0) TTCN_error("Accessing an element of type @HNBGW_Tests.ro_Compl3Type using a negative index: %d.", index_value);
if (index_value >= val_ptr->n_elements) TTCN_error("Index overflow in a value of type @HNBGW_Tests.ro_Compl3Type: The index is %d, but the value has only %d elements.", index_value, val_ptr->n_elements);
return (val_ptr->value_elements[index_value] == NULL) ?
UNBOUND_ELEM : *val_ptr->value_elements[index_value];
}

const Compl3Type& ro__Compl3Type::operator[](const INTEGER& index_value) const
{
index_value.must_bound("Using an unbound integer value for indexing a value of type @HNBGW_Tests.ro_Compl3Type.");
return (*this)[(int)index_value];
}

ro__Compl3Type ro__Compl3Type::operator<<=(int rotate_count) const
{
return *this >>= (-rotate_count);
}

ro__Compl3Type ro__Compl3Type::operator<<=(const INTEGER& rotate_count) const
{
rotate_count.must_bound("Unbound integer operand of rotate left operator.");
return *this >>= (int)(-rotate_count);
}

ro__Compl3Type ro__Compl3Type::operator>>=(const INTEGER& rotate_count) const
{
rotate_count.must_bound("Unbound integer operand of rotate right operator.");
return *this >>= (int)rotate_count;
}

ro__Compl3Type ro__Compl3Type::operator>>=(int rotate_count) const
{
if (val_ptr == NULL) TTCN_error("Performing rotation operation on an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
if (val_ptr->n_elements == 0) return *this;
int rc;
if (rotate_count>=0) rc = rotate_count % val_ptr->n_elements;
else rc = val_ptr->n_elements - ((-rotate_count) % val_ptr->n_elements);
if (rc == 0) return *this;
ro__Compl3Type ret_val;
ret_val.set_size(val_ptr->n_elements);
for (int i=0; i<val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[(i+rc)%val_ptr->n_elements] =new Compl3Type(*val_ptr->value_elements[i]);
}
}
return ret_val;
}

ro__Compl3Type ro__Compl3Type::operator+(const ro__Compl3Type& other_value) const
{
if (val_ptr == NULL || other_value.val_ptr == NULL) TTCN_error("Unbound operand of @HNBGW_Tests.ro_Compl3Type concatenation.");
if (val_ptr->n_elements == 0) return other_value;
if (other_value.val_ptr->n_elements == 0) return *this;
ro__Compl3Type ret_val;
ret_val.set_size(val_ptr->n_elements+other_value.val_ptr->n_elements);
for (int i=0; i<val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i] = new Compl3Type(*val_ptr->value_elements[i]);
}
}
for (int i=0; i<other_value.val_ptr->n_elements; i++) {
if (other_value.val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i+val_ptr->n_elements] = new Compl3Type(*other_value.val_ptr->value_elements[i]);
}
}
return ret_val;
}

ro__Compl3Type ro__Compl3Type::substr(int index, int returncount) const
{
if (val_ptr == NULL) TTCN_error("The first argument of substr() is an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
check_substr_arguments(val_ptr->n_elements, index, returncount, "@HNBGW_Tests.ro_Compl3Type","element");
ro__Compl3Type ret_val;
ret_val.set_size(returncount);
for (int i=0; i<returncount; i++) {
if (val_ptr->value_elements[i+index] != NULL) {
ret_val.val_ptr->value_elements[i] = new Compl3Type(*val_ptr->value_elements[i+index]);
}
}
return ret_val;
}

ro__Compl3Type ro__Compl3Type::replace(int index, int len, const ro__Compl3Type& repl) const
{
if (val_ptr == NULL) TTCN_error("The first argument of replace() is an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
if (repl.val_ptr == NULL) TTCN_error("The fourth argument of replace() is an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
check_replace_arguments(val_ptr->n_elements, index, len, "@HNBGW_Tests.ro_Compl3Type","element");
ro__Compl3Type ret_val;
ret_val.set_size(val_ptr->n_elements + repl.val_ptr->n_elements - len);
for (int i = 0; i < index; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i] = new Compl3Type(*val_ptr->value_elements[i]);
}
}
for (int i = 0; i < repl.val_ptr->n_elements; i++) {
if (repl.val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i+index] = new Compl3Type(*repl.val_ptr->value_elements[i]);
}
}
for (int i = 0; i < val_ptr->n_elements - index - len; i++) {
if (val_ptr->value_elements[index+i+len] != NULL) {
ret_val.val_ptr->value_elements[index+i+repl.val_ptr->n_elements] = new Compl3Type(*val_ptr->value_elements[index+i+len]);
}
}
return ret_val;
}

ro__Compl3Type ro__Compl3Type::replace(int index, int len, const ro__Compl3Type_template& repl) const
{
if (!repl.is_value()) TTCN_error("The fourth argument of function replace() is a template with non-specific value.");
return replace(index, len, repl.valueof());
}

void ro__Compl3Type::set_size(int new_size)
{
if (new_size < 0) TTCN_error("Internal error: Setting a negative size for a value of type @HNBGW_Tests.ro_Compl3Type.");
if (val_ptr == NULL) {
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
} else if (val_ptr->ref_count > 1) {
struct recordof_setof_struct *new_val_ptr = new recordof_setof_struct;
new_val_ptr->ref_count = 1;
new_val_ptr->n_elements = (new_size < val_ptr->n_elements) ? new_size : val_ptr->n_elements;
new_val_ptr->value_elements = (Compl3Type**)allocate_pointers(new_val_ptr->n_elements);
for (int elem_count = 0; elem_count < new_val_ptr->n_elements; elem_count++) {
if (val_ptr->value_elements[elem_count] != NULL){
new_val_ptr->value_elements[elem_count] = new Compl3Type(*(val_ptr->value_elements[elem_count]));
}
}
clean_up();
val_ptr = new_val_ptr;
}
if (new_size > val_ptr->n_elements) {
val_ptr->value_elements = (Compl3Type**)reallocate_pointers((void**)val_ptr->value_elements, val_ptr->n_elements, new_size);
#ifdef TITAN_MEMORY_DEBUG_SET_RECORD_OF
if((val_ptr->n_elements/1000)!=(new_size/1000)) TTCN_warning("New size of type @HNBGW_Tests.ro_Compl3Type: %d",new_size);
#endif
val_ptr->n_elements = new_size;
} else if (new_size < val_ptr->n_elements) {
for (int elem_count = new_size; elem_count < val_ptr->n_elements; elem_count++)
if (val_ptr->value_elements[elem_count] != NULL)delete val_ptr->value_elements[elem_count];
val_ptr->value_elements = (Compl3Type**)reallocate_pointers((void**)val_ptr->value_elements, val_ptr->n_elements, new_size);
val_ptr->n_elements = new_size;
}
}

boolean ro__Compl3Type::is_value() const
{
if (val_ptr == NULL) return FALSE;
for(int i = 0; i < val_ptr->n_elements; ++i) {
if (val_ptr->value_elements[i] == NULL || !val_ptr->value_elements[i]->is_value()) return FALSE;
}
return TRUE;
}

int ro__Compl3Type::size_of() const
{
if (val_ptr == NULL) TTCN_error("Performing sizeof operation on an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
return val_ptr->n_elements;
}

int ro__Compl3Type::lengthof() const
{
if (val_ptr == NULL) TTCN_error("Performing lengthof operation on an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
for (int my_length=val_ptr->n_elements; my_length>0; my_length--) if (val_ptr->value_elements[my_length-1] != NULL) return my_length;
return 0;
}

void ro__Compl3Type::log() const
{
if (val_ptr == NULL) {;
TTCN_Logger::log_event_unbound();
return;
}
switch (val_ptr->n_elements) {
case 0:
TTCN_Logger::log_event_str("{ }");
break;
default:
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
(*this)[elem_count].log();
}
TTCN_Logger::log_event_str(" }");
}
}

void ro__Compl3Type::set_implicit_omit()
{
if (val_ptr == NULL) return;
for (int i = 0; i < val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) val_ptr->value_elements[i]->set_implicit_omit();
}
}

void ro__Compl3Type::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_VALUE|Module_Param::BC_LIST, "record of value");
  switch (param.get_operation_type()) {
  case Module_Param::OT_ASSIGN:
    if (param.get_type()==Module_Param::MP_Value_List && param.get_size()==0) {
      *this = NULL_VALUE;
      return;
    }
    switch (param.get_type()) {
    case Module_Param::MP_Value_List:
      set_size(param.get_size());
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        if (curr->get_type()!=Module_Param::MP_NotUsed) {
          (*this)[i].set_param(*curr);
          if (!(*this)[i].is_bound()) {
            delete val_ptr->value_elements[i];
            val_ptr->value_elements[i] = NULL;
          }
        }
      }
      break;
    case Module_Param::MP_Indexed_List:
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        (*this)[curr->get_id()->get_index()].set_param(*curr);
        if (!(*this)[curr->get_id()->get_index()].is_bound()) {
          delete val_ptr->value_elements[curr->get_id()->get_index()];
          val_ptr->value_elements[curr->get_id()->get_index()] = NULL;
        }
      }
      break;
    default:
      param.type_error("record of value", "@HNBGW_Tests.ro_Compl3Type");
    }
    break;
  case Module_Param::OT_CONCAT:
    switch (param.get_type()) {
    case Module_Param::MP_Value_List: {
      if (!is_bound()) *this = NULL_VALUE;
      int start_idx = lengthof();
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        if ((curr->get_type()!=Module_Param::MP_NotUsed)) {
          (*this)[start_idx+(int)i].set_param(*curr);
        }
      }
    } break;
    case Module_Param::MP_Indexed_List:
      param.error("Cannot concatenate an indexed value list");
      break;
    default:
      param.type_error("record of value", "@HNBGW_Tests.ro_Compl3Type");
    }
    break;
  default:
    TTCN_error("Internal error: Unknown operation type.");
  }
}

void ro__Compl3Type::encode_text(Text_Buf& text_buf) const
{
if (val_ptr == NULL) TTCN_error("Text encoder: Encoding an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
text_buf.push_int(val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++)
(*this)[elem_count].encode_text(text_buf);
}

void ro__Compl3Type::decode_text(Text_Buf& text_buf)
{
clean_up();
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = text_buf.pull_int().get_val();
if (val_ptr->n_elements < 0) TTCN_error("Text decoder: Negative size was received for a value of type @HNBGW_Tests.ro_Compl3Type.");
val_ptr->value_elements = (Compl3Type**)allocate_pointers(val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) {
val_ptr->value_elements[elem_count] = new Compl3Type;
val_ptr->value_elements[elem_count]->decode_text(text_buf);
}
}

void ro__Compl3Type_template::copy_value(const ro__Compl3Type& other_value)
{
if (!other_value.is_bound()) TTCN_error("Initialization of a template of type @HNBGW_Tests.ro_Compl3Type with an unbound value.");
single_value.n_elements = other_value.size_of();
single_value.value_elements = (Compl3Type_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (other_value[elem_count].is_bound()) {
single_value.value_elements[elem_count] = new Compl3Type_template(other_value[elem_count]);
} else {
single_value.value_elements[elem_count] = new Compl3Type_template;
}
}
set_selection(SPECIFIC_VALUE);
}

void ro__Compl3Type_template::copy_template(const ro__Compl3Type_template& other_value)
{
switch (other_value.template_selection) {
case SPECIFIC_VALUE:
single_value.n_elements = other_value.single_value.n_elements;
single_value.value_elements = (Compl3Type_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (UNINITIALIZED_TEMPLATE != other_value.single_value.value_elements[elem_count]->get_selection()) {
single_value.value_elements[elem_count] = new Compl3Type_template(*other_value.single_value.value_elements[elem_count]);
} else {
single_value.value_elements[elem_count] = new Compl3Type_template;
}
}
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
value_list.n_values = other_value.value_list.n_values;
value_list.list_value = new ro__Compl3Type_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]);
break;
case IMPLICATION_MATCH:
implication_.precondition = new ro__Compl3Type_template(*other_value.implication_.precondition);
implication_.implied_template = new ro__Compl3Type_template(*other_value.implication_.implied_template);
break;
case DYNAMIC_MATCH:
dyn_match = other_value.dyn_match;
dyn_match->ref_count++;
break;
default:
TTCN_error("Copying an uninitialized/unsupported template of type @HNBGW_Tests.ro_Compl3Type.");
break;
}
set_selection(other_value);
}

boolean ro__Compl3Type_template::match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy)
{
if (value_index >= 0) return ((const ro__Compl3Type_template*)template_ptr)->single_value.value_elements[template_index]->match((*(const ro__Compl3Type*)value_ptr)[value_index], legacy);
else return ((const ro__Compl3Type_template*)template_ptr)->single_value.value_elements[template_index]->is_any_or_omit();
}

ro__Compl3Type_template::ro__Compl3Type_template()
{
}

ro__Compl3Type_template::ro__Compl3Type_template(template_sel other_value)
 : Base_Record_Of_Template(other_value)
{
check_single_selection(other_value);
}

ro__Compl3Type_template::ro__Compl3Type_template(null_type)
 : Base_Record_Of_Template(SPECIFIC_VALUE)
{
single_value.n_elements = 0;
single_value.value_elements = NULL;
}

ro__Compl3Type_template::ro__Compl3Type_template(const ro__Compl3Type& other_value)
{
copy_value(other_value);
}

ro__Compl3Type_template::ro__Compl3Type_template(const OPTIONAL<ro__Compl3Type>& other_value)
{
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const ro__Compl3Type&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Creating a template of type @HNBGW_Tests.ro_Compl3Type from an unbound optional field.");
}
}

ro__Compl3Type_template::ro__Compl3Type_template(ro__Compl3Type_template* p_precondition, ro__Compl3Type_template* p_implied_template)
 : Base_Record_Of_Template(IMPLICATION_MATCH)
{
implication_.precondition = p_precondition;
implication_.implied_template = p_implied_template;
}

ro__Compl3Type_template::ro__Compl3Type_template(Dynamic_Match_Interface<ro__Compl3Type>* p_dyn_match)
 : Base_Record_Of_Template(DYNAMIC_MATCH)
{
dyn_match = new dynmatch_struct<ro__Compl3Type>;
dyn_match->ptr = p_dyn_match;
dyn_match->ref_count = 1;
}

ro__Compl3Type_template::ro__Compl3Type_template(const ro__Compl3Type_template& other_value)
 : Base_Record_Of_Template()
{
copy_template(other_value);
}

ro__Compl3Type_template::~ro__Compl3Type_template()
{
clean_up();
}

void ro__Compl3Type_template::clean_up()
{
switch (template_selection) {
case SPECIFIC_VALUE:
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
delete single_value.value_elements[elem_count];
free_pointers((void**)single_value.value_elements);
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
delete [] value_list.list_value;
break;
case IMPLICATION_MATCH:
delete implication_.precondition;
delete implication_.implied_template;
break;
case DYNAMIC_MATCH:
dyn_match->ref_count--;
if (dyn_match->ref_count == 0) {
delete dyn_match->ptr;
delete dyn_match;
}
break;
default:
break;
}
template_selection = UNINITIALIZED_TEMPLATE;
}

ro__Compl3Type_template& ro__Compl3Type_template::operator=(template_sel other_value)
{
check_single_selection(other_value);
clean_up();
set_selection(other_value);
return *this;
}

ro__Compl3Type_template& ro__Compl3Type_template::operator=(null_type)
{
clean_up();
set_selection(SPECIFIC_VALUE);
single_value.n_elements = 0;
single_value.value_elements = NULL;
return *this;
}

ro__Compl3Type_template& ro__Compl3Type_template::operator=(const ro__Compl3Type& other_value)
{
clean_up();
copy_value(other_value);
return *this;
}

ro__Compl3Type_template& ro__Compl3Type_template::operator=(const OPTIONAL<ro__Compl3Type>& other_value)
{
clean_up();
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const ro__Compl3Type&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Assignment of an unbound optional field to a template of type @HNBGW_Tests.ro_Compl3Type.");
}
return *this;
}

ro__Compl3Type_template& ro__Compl3Type_template::operator=(const ro__Compl3Type_template& other_value)
{
if (&other_value != this) {
clean_up();
copy_template(other_value);
}
return *this;
}

Compl3Type_template& ro__Compl3Type_template::operator[](int index_value)
{
if (index_value < 0) TTCN_error("Accessing an element of a template for type @HNBGW_Tests.ro_Compl3Type using a negative index: %d.", index_value);
switch (template_selection)
{
  case SPECIFIC_VALUE:
    if(index_value < single_value.n_elements) break;
    // no break
  case OMIT_VALUE:
  case ANY_VALUE:
  case ANY_OR_OMIT:
  case UNINITIALIZED_TEMPLATE:
    set_size(index_value + 1);
    break;
  default:
    TTCN_error("Accessing an element of a non-specific template for type @HNBGW_Tests.ro_Compl3Type.");
    break;
}
return *single_value.value_elements[index_value];
}

Compl3Type_template& ro__Compl3Type_template::operator[](const INTEGER& index_value)
{
index_value.must_bound("Using an unbound integer value for indexing a template of type @HNBGW_Tests.ro_Compl3Type.");
return (*this)[(int)index_value];
}

const Compl3Type_template& ro__Compl3Type_template::operator[](int index_value) const
{
if (index_value < 0) TTCN_error("Accessing an element of a template for type @HNBGW_Tests.ro_Compl3Type using a negative index: %d.", index_value);
if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing an element of a non-specific template for type @HNBGW_Tests.ro_Compl3Type.");
if (index_value >= single_value.n_elements) TTCN_error("Index overflow in a template of type @HNBGW_Tests.ro_Compl3Type: The index is %d, but the template has only %d elements.", index_value, single_value.n_elements);
return *single_value.value_elements[index_value];
}

const Compl3Type_template& ro__Compl3Type_template::operator[](const INTEGER& index_value) const
{
index_value.must_bound("Using an unbound integer value for indexing a template of type @HNBGW_Tests.ro_Compl3Type.");
return (*this)[(int)index_value];
}

void ro__Compl3Type_template::set_size(int new_size)
{
if (new_size < 0) TTCN_error("Internal error: Setting a negative size for a template of type @HNBGW_Tests.ro_Compl3Type.");
template_sel old_selection = template_selection;
if (old_selection != SPECIFIC_VALUE) {
clean_up();
set_selection(SPECIFIC_VALUE);
single_value.n_elements = 0;
single_value.value_elements = NULL;
}
if (new_size > single_value.n_elements) {
single_value.value_elements = (Compl3Type_template**)reallocate_pointers((void**)single_value.value_elements, single_value.n_elements, new_size);
if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) {
for (int elem_count = single_value.n_elements; elem_count < new_size; elem_count++)
single_value.value_elements[elem_count] = new Compl3Type_template(ANY_VALUE);
} else {
for (int elem_count = single_value.n_elements; elem_count < new_size; elem_count++)
single_value.value_elements[elem_count] = new Compl3Type_template;
}
single_value.n_elements = new_size;
} else if (new_size < single_value.n_elements) {
for (int elem_count = new_size; elem_count < single_value.n_elements; elem_count++)
delete single_value.value_elements[elem_count];
single_value.value_elements = (Compl3Type_template**)reallocate_pointers((void**)single_value.value_elements, single_value.n_elements, new_size);
single_value.n_elements = new_size;
}
}

int ro__Compl3Type_template::n_elem() const
{
  switch (template_selection) {
  case SPECIFIC_VALUE:
    return single_value.n_elements;
    break;
  case VALUE_LIST:
    return value_list.n_values;
    break;
  default:
    TTCN_error("Performing n_elem");
  }
}

int ro__Compl3Type_template::size_of(boolean is_size) const
{
const char* op_name = is_size ? "size" : "length";
int min_size;
boolean has_any_or_none;
if (is_ifpresent) TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_Compl3Type which has an ifpresent attribute.", op_name);
switch (template_selection)
{
case SPECIFIC_VALUE: {
  min_size = 0;
  has_any_or_none = FALSE;
  int elem_count = single_value.n_elements;
  if (!is_size) { while (elem_count>0 && !single_value.value_elements[elem_count-1]->is_bound()) elem_count--; }
  for (int i=0; i<elem_count; i++) {
    switch (single_value.value_elements[i]->get_selection()) {
    case OMIT_VALUE:
      TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_Compl3Type containing omit element.", op_name);
    case ANY_OR_OMIT:
      has_any_or_none = TRUE;
      break;
    default:
      min_size++;
      break;
    }
  }
} break;
case OMIT_VALUE:
  TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_Compl3Type containing omit value.", op_name);
case ANY_VALUE:
case ANY_OR_OMIT:
  min_size = 0;
  has_any_or_none = TRUE;
  break;
case VALUE_LIST:
{
  if (value_list.n_values<1)
    TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_Compl3Type containing an empty list.", op_name);
  int item_size = value_list.list_value[0].size_of(is_size);
  for (unsigned int i = 1; i < value_list.n_values; i++) {
    if (value_list.list_value[i].size_of(is_size)!=item_size)
      TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_Compl3Type containing a value list with different sizes.", op_name);
  }
  min_size = item_size;
  has_any_or_none = FALSE;
  break;
}
case COMPLEMENTED_LIST:
  TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_Compl3Type containing complemented list.", op_name);
default:
  TTCN_error("Performing %sof() operation on an uninitialized/unsupported template of type @HNBGW_Tests.ro_Compl3Type.", op_name);
}
return check_section_is_single(min_size, has_any_or_none, op_name, "a", "template of type @HNBGW_Tests.ro_Compl3Type");
}

boolean ro__Compl3Type_template::match(const ro__Compl3Type& other_value, boolean legacy) const
{
if (!other_value.is_bound()) return FALSE;
int value_length = other_value.size_of();
if (!match_length(value_length)) return FALSE;
switch (template_selection) {
case SPECIFIC_VALUE:
return match_record_of(&other_value, value_length, this, single_value.n_elements, match_function_specific, legacy);
case OMIT_VALUE:
return FALSE;
case ANY_VALUE:
case ANY_OR_OMIT:
return TRUE;
case VALUE_LIST:
case COMPLEMENTED_LIST:
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST;
return template_selection == COMPLEMENTED_LIST;
case CONJUNCTION_MATCH:
for (unsigned int i = 0; i < value_list.n_values; i++) {
if (!value_list.list_value[i].match(other_value)) {
return FALSE;
}
}
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value);
case DYNAMIC_MATCH:
return dyn_match->ptr->match(other_value);
default:
TTCN_error("Matching with an uninitialized/unsupported template of type @HNBGW_Tests.ro_Compl3Type.");
}
return FALSE;
}

boolean ro__Compl3Type_template::is_value() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE;
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
if (!single_value.value_elements[elem_count]->is_value()) return FALSE;
return TRUE;
}

ro__Compl3Type ro__Compl3Type_template::valueof() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of type @HNBGW_Tests.ro_Compl3Type.");
ro__Compl3Type ret_val;
ret_val.set_size(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
if (single_value.value_elements[elem_count]->is_bound()) {
ret_val[elem_count] = single_value.value_elements[elem_count]->valueof();
}
return ret_val;
}

ro__Compl3Type ro__Compl3Type_template::substr(int index, int returncount) const
{
if (!is_value()) TTCN_error("The first argument of function substr() is a template with non-specific value.");
return valueof().substr(index, returncount);
}

ro__Compl3Type ro__Compl3Type_template::replace(int index, int len, const ro__Compl3Type_template& repl) const
{
if (!is_value()) TTCN_error("The first argument of function replace() is a template with non-specific value.");
if (!repl.is_value()) TTCN_error("The fourth argument of function replace() is a template with non-specific value.");
return valueof().replace(index, len, repl.valueof());
}

ro__Compl3Type ro__Compl3Type_template::replace(int index, int len, const ro__Compl3Type& repl) const
{
if (!is_value()) TTCN_error("The first argument of function replace() is a template with non-specific value.");
return valueof().replace(index, len, repl);
}

void ro__Compl3Type_template::set_type(template_sel template_type, unsigned int list_length)
{
clean_up();
switch (template_type) {
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
value_list.n_values = list_length;
value_list.list_value = new ro__Compl3Type_template[list_length];
break;
default:
TTCN_error("Internal error: Setting an invalid type for a template of type @HNBGW_Tests.ro_Compl3Type.");
}
set_selection(template_type);
}

ro__Compl3Type_template& ro__Compl3Type_template::list_item(unsigned int list_index)
{
if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST && template_selection != CONJUNCTION_MATCH) TTCN_error("Internal error: Accessing a list element of a non-list template of type @HNBGW_Tests.ro_Compl3Type.");
if (list_index >= value_list.n_values) TTCN_error("Internal error: Index overflow in a value list template of type @HNBGW_Tests.ro_Compl3Type.");
return value_list.list_value[list_index];
}

void ro__Compl3Type_template::log() const
{
switch (template_selection) {
case SPECIFIC_VALUE:
if (single_value.n_elements > 0) {
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
if (permutation_starts_at(elem_count)) TTCN_Logger::log_event_str("permutation(");
single_value.value_elements[elem_count]->log();
if (permutation_ends_at(elem_count)) TTCN_Logger::log_char(')');
}
TTCN_Logger::log_event_str(" }");
} else TTCN_Logger::log_event_str("{ }");
break;
case COMPLEMENTED_LIST:
TTCN_Logger::log_event_str("complement");
case CONJUNCTION_MATCH:
if (template_selection == CONJUNCTION_MATCH) {
TTCN_Logger::log_event_str("conjunct");
}
case VALUE_LIST:
TTCN_Logger::log_char('(');
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) {
if (list_count > 0) TTCN_Logger::log_event_str(", ");
value_list.list_value[list_count].log();
}
TTCN_Logger::log_char(')');
break;
case IMPLICATION_MATCH:
implication_.precondition->log();
TTCN_Logger::log_event_str(" implies ");
implication_.implied_template->log();
break;
case DYNAMIC_MATCH:
TTCN_Logger::log_event_str("@dynamic template");
break;
default:
log_generic();
}
log_restricted();
log_ifpresent();
}

void ro__Compl3Type_template::log_match(const ro__Compl3Type& match_value, boolean legacy) const
{
if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){
if(match(match_value, legacy)){
TTCN_Logger::print_logmatch_buffer();
TTCN_Logger::log_event_str(" matched");
}else{
if (template_selection == SPECIFIC_VALUE && single_value.n_elements > 0 && get_number_of_permutations() == 0 && single_value.n_elements == match_value.size_of()) {
size_t previous_size = TTCN_Logger::get_logmatch_buffer_len();
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if(!single_value.value_elements[elem_count]->match(match_value[elem_count], legacy)){
TTCN_Logger::log_logmatch_info("[%d]", elem_count);
single_value.value_elements[elem_count]->log_match(match_value[elem_count], legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
}
log_match_length(single_value.n_elements);
} else {
TTCN_Logger::print_logmatch_buffer();
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
TTCN_Logger::log_event_str(" unmatched");
}
}
return;
}
if (template_selection == SPECIFIC_VALUE && single_value.n_elements > 0 && get_number_of_permutations() == 0 && single_value.n_elements == match_value.size_of()) {
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
single_value.value_elements[elem_count]->log_match(match_value[elem_count], legacy);
}
TTCN_Logger::log_event_str(" }");
log_match_length(single_value.n_elements);
} else {
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched");
else TTCN_Logger::log_event_str(" unmatched");
}
}

void ro__Compl3Type_template::encode_text(Text_Buf& text_buf) const
{
encode_text_permutation(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
text_buf.push_int(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
single_value.value_elements[elem_count]->encode_text(text_buf);
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
text_buf.push_int(value_list.n_values);
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].encode_text(text_buf);
break;
default:
TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @HNBGW_Tests.ro_Compl3Type.");
}
}

void ro__Compl3Type_template::decode_text(Text_Buf& text_buf)
{
clean_up();
decode_text_permutation(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value.n_elements = text_buf.pull_int().get_val();
if (single_value.n_elements < 0) TTCN_error("Text decoder: Negative size was received for a template of type @HNBGW_Tests.ro_Compl3Type.");
single_value.value_elements = (Compl3Type_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
single_value.value_elements[elem_count] = new Compl3Type_template;
single_value.value_elements[elem_count]->decode_text(text_buf);
}
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
value_list.n_values = text_buf.pull_int().get_val();
value_list.list_value = new ro__Compl3Type_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].decode_text(text_buf);
break;
default:
TTCN_error("Text decoder: An unknown/unsupported selection was received for a template of type @HNBGW_Tests.ro_Compl3Type.");
}
}

boolean ro__Compl3Type_template::is_present(boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE;
return !match_omit(legacy);
}

boolean ro__Compl3Type_template::match_omit(boolean legacy) const
{
if (is_ifpresent) return TRUE;
switch (template_selection) {
case OMIT_VALUE:
case ANY_OR_OMIT:
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match_omit() || implication_.implied_template->match_omit();
case VALUE_LIST:
case COMPLEMENTED_LIST:
if (legacy) {
for (unsigned int i=0; i<value_list.n_values; i++)
if (value_list.list_value[i].match_omit())
return template_selection==VALUE_LIST;
return template_selection==COMPLEMENTED_LIST;
} // else fall through
default:
return FALSE;
}
return FALSE;
}

void ro__Compl3Type_template::set_implicit_omit()
{
if (template_selection != SPECIFIC_VALUE) return;
for (int i = 0; i < single_value.n_elements; i++) {
if (single_value.value_elements[i] != NULL) single_value.value_elements[i]->set_implicit_omit();
}
}

void ro__Compl3Type_template::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_TEMPLATE|Module_Param::BC_LIST, "record of template");
  switch (param.get_type()) {
  case Module_Param::MP_Omit:
    *this = OMIT_VALUE;
    break;
  case Module_Param::MP_Any:
    *this = ANY_VALUE;
    break;
  case Module_Param::MP_AnyOrNone:
    *this = ANY_OR_OMIT;
    break;
  case Module_Param::MP_List_Template:
  case Module_Param::MP_ComplementList_Template:
  case Module_Param::MP_ConjunctList_Template: {
    ro__Compl3Type_template temp;
    temp.set_type(param.get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (param.get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), param.get_size());
    for (size_t p_i=0; p_i<param.get_size(); p_i++) {
      temp.list_item(p_i).set_param(*param.get_elem(p_i));
    }
    *this = temp;
    break; }
  case Module_Param::MP_Indexed_List:
    if (template_selection!=SPECIFIC_VALUE) set_size(0);
    for (size_t p_i=0; p_i<param.get_size(); ++p_i) {
      (*this)[(int)(param.get_elem(p_i)->get_id()->get_index())].set_param(*param.get_elem(p_i));
    }
    break;
  case Module_Param::MP_Value_List: {
    set_size(param.get_size());
    int curr_idx = 0;
    for (size_t p_i=0; p_i<param.get_size(); ++p_i) {
      switch (param.get_elem(p_i)->get_type()) {
      case Module_Param::MP_NotUsed:
        curr_idx++;
        break;
      case Module_Param::MP_Permutation_Template: {
        int perm_start_idx = curr_idx;
        Module_Param* param_i = param.get_elem(p_i);
        for (size_t perm_i=0; perm_i<param_i->get_size(); perm_i++) {
          (*this)[curr_idx].set_param(*(param_i->get_elem(perm_i)));
          curr_idx++;
        }
        int perm_end_idx = curr_idx - 1;
        add_permutation(perm_start_idx, perm_end_idx);
      } break;
      default:
        (*this)[curr_idx].set_param(*param.get_elem(p_i));
        curr_idx++;
      }
    }
  } break;
  case Module_Param::MP_Implication_Template: {
    ro__Compl3Type_template* precondition = new ro__Compl3Type_template;
    precondition->set_param(*param.get_elem(0));
    ro__Compl3Type_template* implied_template = new ro__Compl3Type_template;
    implied_template->set_param(*param.get_elem(1));
    *this = ro__Compl3Type_template(precondition, implied_template);
  } break;
  default:
    param.type_error("record of template", "@HNBGW_Tests.ro_Compl3Type");
  }
  is_ifpresent = param.get_ifpresent();
  set_length_range(param);
}

void ro__Compl3Type_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return;
switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) {
case TR_OMIT:
if (template_selection==OMIT_VALUE) return;
case TR_VALUE:
if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break;
for (int i=0; i<single_value.n_elements; i++) single_value.value_elements[i]->check_restriction(t_res, t_name ? t_name : "@HNBGW_Tests.ro_Compl3Type");
return;
case TR_PRESENT:
if (!match_omit(legacy)) return;
break;
default:
return;
}
TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@HNBGW_Tests.ro_Compl3Type");
}

boolean ro__Compl3Type_template::get_istemplate_kind(const char* type) const {
if (!strcmp(type, "AnyElement")) {
  if (template_selection != SPECIFIC_VALUE) {
    return FALSE;
  }
  for (int i = 0; i < single_value.n_elements; i++) {
    if (single_value.value_elements[i]->get_selection() == ANY_VALUE) {
      return TRUE;
    }
  }
  return FALSE;
} else if (!strcmp(type, "AnyElementsOrNone")) {
  if (template_selection != SPECIFIC_VALUE) {
    return FALSE;
  }
  for (int i = 0; i < single_value.n_elements; i++) {
    if (single_value.value_elements[i]->get_selection() == ANY_OR_OMIT) {
      return TRUE;
    }
  }
  return FALSE;
} else if (!strcmp(type, "permutation")) {
  return number_of_permutations;
} else if (!strcmp(type, "length")) {
  return length_restriction_type != NO_LENGTH_RESTRICTION;
} else {
  return Base_Template::get_istemplate_kind(type);
}
}

const MobileL3__CommonIE__Types::MobileIdentityLV ro__MobileIdentityLV::UNBOUND_ELEM;
ro__MobileIdentityLV::ro__MobileIdentityLV()
{
val_ptr = NULL;
}

ro__MobileIdentityLV::ro__MobileIdentityLV(null_type)
{
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
}

ro__MobileIdentityLV::ro__MobileIdentityLV(const ro__MobileIdentityLV& other_value)
{
if (!other_value.is_bound()) TTCN_error("Copying an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
val_ptr = other_value.val_ptr;
val_ptr->ref_count++;
}

ro__MobileIdentityLV::~ro__MobileIdentityLV()
{
clean_up();
if (val_ptr != NULL) val_ptr = NULL;
}

void ro__MobileIdentityLV::clean_up()
{
if (val_ptr != NULL) {
if (val_ptr->ref_count > 1) {
val_ptr->ref_count--;
val_ptr = NULL;
}
else if (val_ptr->ref_count == 1) {
for (int elem_count = 0; elem_count < val_ptr->n_elements;
elem_count++)
if (val_ptr->value_elements[elem_count] != NULL)
delete val_ptr->value_elements[elem_count];
free_pointers((void**)val_ptr->value_elements);
delete val_ptr;
val_ptr = NULL;
}
else
TTCN_error("Internal error: Invalid reference counter in a record of/set of value.");
}
}

ro__MobileIdentityLV& ro__MobileIdentityLV::operator=(null_type)
{
clean_up();
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
return *this;
}

ro__MobileIdentityLV& ro__MobileIdentityLV::operator=(const ro__MobileIdentityLV& other_value)
{
if (other_value.val_ptr == NULL) TTCN_error("Assigning an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
if (this != &other_value) {
clean_up();
val_ptr = other_value.val_ptr;
val_ptr->ref_count++;
}
return *this;
}

boolean ro__MobileIdentityLV::operator==(null_type) const
{
if (val_ptr == NULL)
TTCN_error("The left operand of comparison is an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
return val_ptr->n_elements == 0 ;
}

boolean ro__MobileIdentityLV::operator==(const ro__MobileIdentityLV& other_value) const
{
if (val_ptr == NULL) TTCN_error("The left operand of comparison is an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
if (val_ptr == other_value.val_ptr) return TRUE;
if (val_ptr->n_elements != (other_value.val_ptr)->n_elements)
return FALSE;
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++){
if (val_ptr->value_elements[elem_count] != NULL){
if ((other_value.val_ptr)->value_elements[elem_count] != NULL){
  if (*val_ptr->value_elements[elem_count] != *(other_value.val_ptr)->value_elements[elem_count]) return FALSE;
} else return FALSE;
} else {
if ((other_value.val_ptr)->value_elements[elem_count] != NULL) return FALSE;
}
}
return TRUE;
}

MobileL3__CommonIE__Types::MobileIdentityLV& ro__MobileIdentityLV::operator[](int index_value)
{
if (index_value < 0) TTCN_error("Accessing an element of type @HNBGW_Tests.ro_MobileIdentityLV using a negative index: %d.", index_value);
if (val_ptr == NULL) {
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
} else if (val_ptr->ref_count > 1) {
struct recordof_setof_struct *new_val_ptr = new recordof_setof_struct;
new_val_ptr->ref_count = 1;
new_val_ptr->n_elements = (index_value >= val_ptr->n_elements) ? index_value + 1 : val_ptr->n_elements;
new_val_ptr->value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV**)allocate_pointers(new_val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++){
if (val_ptr->value_elements[elem_count] != NULL){
new_val_ptr->value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV(*(val_ptr->value_elements[elem_count]));
}
}
clean_up();
val_ptr = new_val_ptr;
}
if (index_value >= val_ptr->n_elements) set_size(index_value + 1);
if (val_ptr->value_elements[index_value] == NULL) {
val_ptr->value_elements[index_value] = new MobileL3__CommonIE__Types::MobileIdentityLV;
}
return *val_ptr->value_elements[index_value];
}

MobileL3__CommonIE__Types::MobileIdentityLV& ro__MobileIdentityLV::operator[](const INTEGER& index_value)
{
index_value.must_bound("Using an unbound integer value for indexing a value of type @HNBGW_Tests.ro_MobileIdentityLV.");
return (*this)[(int)index_value];
}

const MobileL3__CommonIE__Types::MobileIdentityLV& ro__MobileIdentityLV::operator[](int index_value) const
{
if (val_ptr == NULL)
TTCN_error("Accessing an element in an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
if (index_value < 0) TTCN_error("Accessing an element of type @HNBGW_Tests.ro_MobileIdentityLV using a negative index: %d.", index_value);
if (index_value >= val_ptr->n_elements) TTCN_error("Index overflow in a value of type @HNBGW_Tests.ro_MobileIdentityLV: The index is %d, but the value has only %d elements.", index_value, val_ptr->n_elements);
return (val_ptr->value_elements[index_value] == NULL) ?
UNBOUND_ELEM : *val_ptr->value_elements[index_value];
}

const MobileL3__CommonIE__Types::MobileIdentityLV& ro__MobileIdentityLV::operator[](const INTEGER& index_value) const
{
index_value.must_bound("Using an unbound integer value for indexing a value of type @HNBGW_Tests.ro_MobileIdentityLV.");
return (*this)[(int)index_value];
}

ro__MobileIdentityLV ro__MobileIdentityLV::operator<<=(int rotate_count) const
{
return *this >>= (-rotate_count);
}

ro__MobileIdentityLV ro__MobileIdentityLV::operator<<=(const INTEGER& rotate_count) const
{
rotate_count.must_bound("Unbound integer operand of rotate left operator.");
return *this >>= (int)(-rotate_count);
}

ro__MobileIdentityLV ro__MobileIdentityLV::operator>>=(const INTEGER& rotate_count) const
{
rotate_count.must_bound("Unbound integer operand of rotate right operator.");
return *this >>= (int)rotate_count;
}

ro__MobileIdentityLV ro__MobileIdentityLV::operator>>=(int rotate_count) const
{
if (val_ptr == NULL) TTCN_error("Performing rotation operation on an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
if (val_ptr->n_elements == 0) return *this;
int rc;
if (rotate_count>=0) rc = rotate_count % val_ptr->n_elements;
else rc = val_ptr->n_elements - ((-rotate_count) % val_ptr->n_elements);
if (rc == 0) return *this;
ro__MobileIdentityLV ret_val;
ret_val.set_size(val_ptr->n_elements);
for (int i=0; i<val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[(i+rc)%val_ptr->n_elements] =new MobileL3__CommonIE__Types::MobileIdentityLV(*val_ptr->value_elements[i]);
}
}
return ret_val;
}

ro__MobileIdentityLV ro__MobileIdentityLV::operator+(const ro__MobileIdentityLV& other_value) const
{
if (val_ptr == NULL || other_value.val_ptr == NULL) TTCN_error("Unbound operand of @HNBGW_Tests.ro_MobileIdentityLV concatenation.");
if (val_ptr->n_elements == 0) return other_value;
if (other_value.val_ptr->n_elements == 0) return *this;
ro__MobileIdentityLV ret_val;
ret_val.set_size(val_ptr->n_elements+other_value.val_ptr->n_elements);
for (int i=0; i<val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i] = new MobileL3__CommonIE__Types::MobileIdentityLV(*val_ptr->value_elements[i]);
}
}
for (int i=0; i<other_value.val_ptr->n_elements; i++) {
if (other_value.val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i+val_ptr->n_elements] = new MobileL3__CommonIE__Types::MobileIdentityLV(*other_value.val_ptr->value_elements[i]);
}
}
return ret_val;
}

ro__MobileIdentityLV ro__MobileIdentityLV::substr(int index, int returncount) const
{
if (val_ptr == NULL) TTCN_error("The first argument of substr() is an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
check_substr_arguments(val_ptr->n_elements, index, returncount, "@HNBGW_Tests.ro_MobileIdentityLV","element");
ro__MobileIdentityLV ret_val;
ret_val.set_size(returncount);
for (int i=0; i<returncount; i++) {
if (val_ptr->value_elements[i+index] != NULL) {
ret_val.val_ptr->value_elements[i] = new MobileL3__CommonIE__Types::MobileIdentityLV(*val_ptr->value_elements[i+index]);
}
}
return ret_val;
}

ro__MobileIdentityLV ro__MobileIdentityLV::replace(int index, int len, const ro__MobileIdentityLV& repl) const
{
if (val_ptr == NULL) TTCN_error("The first argument of replace() is an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
if (repl.val_ptr == NULL) TTCN_error("The fourth argument of replace() is an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
check_replace_arguments(val_ptr->n_elements, index, len, "@HNBGW_Tests.ro_MobileIdentityLV","element");
ro__MobileIdentityLV ret_val;
ret_val.set_size(val_ptr->n_elements + repl.val_ptr->n_elements - len);
for (int i = 0; i < index; i++) {
if (val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i] = new MobileL3__CommonIE__Types::MobileIdentityLV(*val_ptr->value_elements[i]);
}
}
for (int i = 0; i < repl.val_ptr->n_elements; i++) {
if (repl.val_ptr->value_elements[i] != NULL) {
ret_val.val_ptr->value_elements[i+index] = new MobileL3__CommonIE__Types::MobileIdentityLV(*repl.val_ptr->value_elements[i]);
}
}
for (int i = 0; i < val_ptr->n_elements - index - len; i++) {
if (val_ptr->value_elements[index+i+len] != NULL) {
ret_val.val_ptr->value_elements[index+i+repl.val_ptr->n_elements] = new MobileL3__CommonIE__Types::MobileIdentityLV(*val_ptr->value_elements[index+i+len]);
}
}
return ret_val;
}

ro__MobileIdentityLV ro__MobileIdentityLV::replace(int index, int len, const ro__MobileIdentityLV_template& repl) const
{
if (!repl.is_value()) TTCN_error("The fourth argument of function replace() is a template with non-specific value.");
return replace(index, len, repl.valueof());
}

void ro__MobileIdentityLV::set_size(int new_size)
{
if (new_size < 0) TTCN_error("Internal error: Setting a negative size for a value of type @HNBGW_Tests.ro_MobileIdentityLV.");
if (val_ptr == NULL) {
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
val_ptr->value_elements = NULL;
} else if (val_ptr->ref_count > 1) {
struct recordof_setof_struct *new_val_ptr = new recordof_setof_struct;
new_val_ptr->ref_count = 1;
new_val_ptr->n_elements = (new_size < val_ptr->n_elements) ? new_size : val_ptr->n_elements;
new_val_ptr->value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV**)allocate_pointers(new_val_ptr->n_elements);
for (int elem_count = 0; elem_count < new_val_ptr->n_elements; elem_count++) {
if (val_ptr->value_elements[elem_count] != NULL){
new_val_ptr->value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV(*(val_ptr->value_elements[elem_count]));
}
}
clean_up();
val_ptr = new_val_ptr;
}
if (new_size > val_ptr->n_elements) {
val_ptr->value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV**)reallocate_pointers((void**)val_ptr->value_elements, val_ptr->n_elements, new_size);
#ifdef TITAN_MEMORY_DEBUG_SET_RECORD_OF
if((val_ptr->n_elements/1000)!=(new_size/1000)) TTCN_warning("New size of type @HNBGW_Tests.ro_MobileIdentityLV: %d",new_size);
#endif
val_ptr->n_elements = new_size;
} else if (new_size < val_ptr->n_elements) {
for (int elem_count = new_size; elem_count < val_ptr->n_elements; elem_count++)
if (val_ptr->value_elements[elem_count] != NULL)delete val_ptr->value_elements[elem_count];
val_ptr->value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV**)reallocate_pointers((void**)val_ptr->value_elements, val_ptr->n_elements, new_size);
val_ptr->n_elements = new_size;
}
}

boolean ro__MobileIdentityLV::is_value() const
{
if (val_ptr == NULL) return FALSE;
for(int i = 0; i < val_ptr->n_elements; ++i) {
if (val_ptr->value_elements[i] == NULL || !val_ptr->value_elements[i]->is_value()) return FALSE;
}
return TRUE;
}

int ro__MobileIdentityLV::size_of() const
{
if (val_ptr == NULL) TTCN_error("Performing sizeof operation on an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
return val_ptr->n_elements;
}

int ro__MobileIdentityLV::lengthof() const
{
if (val_ptr == NULL) TTCN_error("Performing lengthof operation on an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
for (int my_length=val_ptr->n_elements; my_length>0; my_length--) if (val_ptr->value_elements[my_length-1] != NULL) return my_length;
return 0;
}

void ro__MobileIdentityLV::log() const
{
if (val_ptr == NULL) {;
TTCN_Logger::log_event_unbound();
return;
}
switch (val_ptr->n_elements) {
case 0:
TTCN_Logger::log_event_str("{ }");
break;
default:
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
(*this)[elem_count].log();
}
TTCN_Logger::log_event_str(" }");
}
}

void ro__MobileIdentityLV::set_implicit_omit()
{
if (val_ptr == NULL) return;
for (int i = 0; i < val_ptr->n_elements; i++) {
if (val_ptr->value_elements[i] != NULL) val_ptr->value_elements[i]->set_implicit_omit();
}
}

void ro__MobileIdentityLV::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_VALUE|Module_Param::BC_LIST, "record of value");
  switch (param.get_operation_type()) {
  case Module_Param::OT_ASSIGN:
    if (param.get_type()==Module_Param::MP_Value_List && param.get_size()==0) {
      *this = NULL_VALUE;
      return;
    }
    switch (param.get_type()) {
    case Module_Param::MP_Value_List:
      set_size(param.get_size());
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        if (curr->get_type()!=Module_Param::MP_NotUsed) {
          (*this)[i].set_param(*curr);
          if (!(*this)[i].is_bound()) {
            delete val_ptr->value_elements[i];
            val_ptr->value_elements[i] = NULL;
          }
        }
      }
      break;
    case Module_Param::MP_Indexed_List:
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        (*this)[curr->get_id()->get_index()].set_param(*curr);
        if (!(*this)[curr->get_id()->get_index()].is_bound()) {
          delete val_ptr->value_elements[curr->get_id()->get_index()];
          val_ptr->value_elements[curr->get_id()->get_index()] = NULL;
        }
      }
      break;
    default:
      param.type_error("record of value", "@HNBGW_Tests.ro_MobileIdentityLV");
    }
    break;
  case Module_Param::OT_CONCAT:
    switch (param.get_type()) {
    case Module_Param::MP_Value_List: {
      if (!is_bound()) *this = NULL_VALUE;
      int start_idx = lengthof();
      for (size_t i=0; i<param.get_size(); ++i) {
        Module_Param* const curr = param.get_elem(i);
        if ((curr->get_type()!=Module_Param::MP_NotUsed)) {
          (*this)[start_idx+(int)i].set_param(*curr);
        }
      }
    } break;
    case Module_Param::MP_Indexed_List:
      param.error("Cannot concatenate an indexed value list");
      break;
    default:
      param.type_error("record of value", "@HNBGW_Tests.ro_MobileIdentityLV");
    }
    break;
  default:
    TTCN_error("Internal error: Unknown operation type.");
  }
}

void ro__MobileIdentityLV::encode_text(Text_Buf& text_buf) const
{
if (val_ptr == NULL) TTCN_error("Text encoder: Encoding an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
text_buf.push_int(val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++)
(*this)[elem_count].encode_text(text_buf);
}

void ro__MobileIdentityLV::decode_text(Text_Buf& text_buf)
{
clean_up();
val_ptr = new recordof_setof_struct;
val_ptr->ref_count = 1;
val_ptr->n_elements = text_buf.pull_int().get_val();
if (val_ptr->n_elements < 0) TTCN_error("Text decoder: Negative size was received for a value of type @HNBGW_Tests.ro_MobileIdentityLV.");
val_ptr->value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV**)allocate_pointers(val_ptr->n_elements);
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) {
val_ptr->value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV;
val_ptr->value_elements[elem_count]->decode_text(text_buf);
}
}

void ro__MobileIdentityLV_template::copy_value(const ro__MobileIdentityLV& other_value)
{
if (!other_value.is_bound()) TTCN_error("Initialization of a template of type @HNBGW_Tests.ro_MobileIdentityLV with an unbound value.");
single_value.n_elements = other_value.size_of();
single_value.value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (other_value[elem_count].is_bound()) {
single_value.value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV_template(other_value[elem_count]);
} else {
single_value.value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV_template;
}
}
set_selection(SPECIFIC_VALUE);
}

void ro__MobileIdentityLV_template::copy_template(const ro__MobileIdentityLV_template& other_value)
{
switch (other_value.template_selection) {
case SPECIFIC_VALUE:
single_value.n_elements = other_value.single_value.n_elements;
single_value.value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (UNINITIALIZED_TEMPLATE != other_value.single_value.value_elements[elem_count]->get_selection()) {
single_value.value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV_template(*other_value.single_value.value_elements[elem_count]);
} else {
single_value.value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV_template;
}
}
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
value_list.n_values = other_value.value_list.n_values;
value_list.list_value = new ro__MobileIdentityLV_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]);
break;
case IMPLICATION_MATCH:
implication_.precondition = new ro__MobileIdentityLV_template(*other_value.implication_.precondition);
implication_.implied_template = new ro__MobileIdentityLV_template(*other_value.implication_.implied_template);
break;
case DYNAMIC_MATCH:
dyn_match = other_value.dyn_match;
dyn_match->ref_count++;
break;
default:
TTCN_error("Copying an uninitialized/unsupported template of type @HNBGW_Tests.ro_MobileIdentityLV.");
break;
}
set_selection(other_value);
}

boolean ro__MobileIdentityLV_template::match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy)
{
if (value_index >= 0) return ((const ro__MobileIdentityLV_template*)template_ptr)->single_value.value_elements[template_index]->match((*(const ro__MobileIdentityLV*)value_ptr)[value_index], legacy);
else return ((const ro__MobileIdentityLV_template*)template_ptr)->single_value.value_elements[template_index]->is_any_or_omit();
}

ro__MobileIdentityLV_template::ro__MobileIdentityLV_template()
{
}

ro__MobileIdentityLV_template::ro__MobileIdentityLV_template(template_sel other_value)
 : Base_Record_Of_Template(other_value)
{
check_single_selection(other_value);
}

ro__MobileIdentityLV_template::ro__MobileIdentityLV_template(null_type)
 : Base_Record_Of_Template(SPECIFIC_VALUE)
{
single_value.n_elements = 0;
single_value.value_elements = NULL;
}

ro__MobileIdentityLV_template::ro__MobileIdentityLV_template(const ro__MobileIdentityLV& other_value)
{
copy_value(other_value);
}

ro__MobileIdentityLV_template::ro__MobileIdentityLV_template(const OPTIONAL<ro__MobileIdentityLV>& other_value)
{
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const ro__MobileIdentityLV&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Creating a template of type @HNBGW_Tests.ro_MobileIdentityLV from an unbound optional field.");
}
}

ro__MobileIdentityLV_template::ro__MobileIdentityLV_template(ro__MobileIdentityLV_template* p_precondition, ro__MobileIdentityLV_template* p_implied_template)
 : Base_Record_Of_Template(IMPLICATION_MATCH)
{
implication_.precondition = p_precondition;
implication_.implied_template = p_implied_template;
}

ro__MobileIdentityLV_template::ro__MobileIdentityLV_template(Dynamic_Match_Interface<ro__MobileIdentityLV>* p_dyn_match)
 : Base_Record_Of_Template(DYNAMIC_MATCH)
{
dyn_match = new dynmatch_struct<ro__MobileIdentityLV>;
dyn_match->ptr = p_dyn_match;
dyn_match->ref_count = 1;
}

ro__MobileIdentityLV_template::ro__MobileIdentityLV_template(const ro__MobileIdentityLV_template& other_value)
 : Base_Record_Of_Template()
{
copy_template(other_value);
}

ro__MobileIdentityLV_template::~ro__MobileIdentityLV_template()
{
clean_up();
}

void ro__MobileIdentityLV_template::clean_up()
{
switch (template_selection) {
case SPECIFIC_VALUE:
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
delete single_value.value_elements[elem_count];
free_pointers((void**)single_value.value_elements);
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
delete [] value_list.list_value;
break;
case IMPLICATION_MATCH:
delete implication_.precondition;
delete implication_.implied_template;
break;
case DYNAMIC_MATCH:
dyn_match->ref_count--;
if (dyn_match->ref_count == 0) {
delete dyn_match->ptr;
delete dyn_match;
}
break;
default:
break;
}
template_selection = UNINITIALIZED_TEMPLATE;
}

ro__MobileIdentityLV_template& ro__MobileIdentityLV_template::operator=(template_sel other_value)
{
check_single_selection(other_value);
clean_up();
set_selection(other_value);
return *this;
}

ro__MobileIdentityLV_template& ro__MobileIdentityLV_template::operator=(null_type)
{
clean_up();
set_selection(SPECIFIC_VALUE);
single_value.n_elements = 0;
single_value.value_elements = NULL;
return *this;
}

ro__MobileIdentityLV_template& ro__MobileIdentityLV_template::operator=(const ro__MobileIdentityLV& other_value)
{
clean_up();
copy_value(other_value);
return *this;
}

ro__MobileIdentityLV_template& ro__MobileIdentityLV_template::operator=(const OPTIONAL<ro__MobileIdentityLV>& other_value)
{
clean_up();
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const ro__MobileIdentityLV&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Assignment of an unbound optional field to a template of type @HNBGW_Tests.ro_MobileIdentityLV.");
}
return *this;
}

ro__MobileIdentityLV_template& ro__MobileIdentityLV_template::operator=(const ro__MobileIdentityLV_template& other_value)
{
if (&other_value != this) {
clean_up();
copy_template(other_value);
}
return *this;
}

MobileL3__CommonIE__Types::MobileIdentityLV_template& ro__MobileIdentityLV_template::operator[](int index_value)
{
if (index_value < 0) TTCN_error("Accessing an element of a template for type @HNBGW_Tests.ro_MobileIdentityLV using a negative index: %d.", index_value);
switch (template_selection)
{
  case SPECIFIC_VALUE:
    if(index_value < single_value.n_elements) break;
    // no break
  case OMIT_VALUE:
  case ANY_VALUE:
  case ANY_OR_OMIT:
  case UNINITIALIZED_TEMPLATE:
    set_size(index_value + 1);
    break;
  default:
    TTCN_error("Accessing an element of a non-specific template for type @HNBGW_Tests.ro_MobileIdentityLV.");
    break;
}
return *single_value.value_elements[index_value];
}

MobileL3__CommonIE__Types::MobileIdentityLV_template& ro__MobileIdentityLV_template::operator[](const INTEGER& index_value)
{
index_value.must_bound("Using an unbound integer value for indexing a template of type @HNBGW_Tests.ro_MobileIdentityLV.");
return (*this)[(int)index_value];
}

const MobileL3__CommonIE__Types::MobileIdentityLV_template& ro__MobileIdentityLV_template::operator[](int index_value) const
{
if (index_value < 0) TTCN_error("Accessing an element of a template for type @HNBGW_Tests.ro_MobileIdentityLV using a negative index: %d.", index_value);
if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing an element of a non-specific template for type @HNBGW_Tests.ro_MobileIdentityLV.");
if (index_value >= single_value.n_elements) TTCN_error("Index overflow in a template of type @HNBGW_Tests.ro_MobileIdentityLV: The index is %d, but the template has only %d elements.", index_value, single_value.n_elements);
return *single_value.value_elements[index_value];
}

const MobileL3__CommonIE__Types::MobileIdentityLV_template& ro__MobileIdentityLV_template::operator[](const INTEGER& index_value) const
{
index_value.must_bound("Using an unbound integer value for indexing a template of type @HNBGW_Tests.ro_MobileIdentityLV.");
return (*this)[(int)index_value];
}

void ro__MobileIdentityLV_template::set_size(int new_size)
{
if (new_size < 0) TTCN_error("Internal error: Setting a negative size for a template of type @HNBGW_Tests.ro_MobileIdentityLV.");
template_sel old_selection = template_selection;
if (old_selection != SPECIFIC_VALUE) {
clean_up();
set_selection(SPECIFIC_VALUE);
single_value.n_elements = 0;
single_value.value_elements = NULL;
}
if (new_size > single_value.n_elements) {
single_value.value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV_template**)reallocate_pointers((void**)single_value.value_elements, single_value.n_elements, new_size);
if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) {
for (int elem_count = single_value.n_elements; elem_count < new_size; elem_count++)
single_value.value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV_template(ANY_VALUE);
} else {
for (int elem_count = single_value.n_elements; elem_count < new_size; elem_count++)
single_value.value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV_template;
}
single_value.n_elements = new_size;
} else if (new_size < single_value.n_elements) {
for (int elem_count = new_size; elem_count < single_value.n_elements; elem_count++)
delete single_value.value_elements[elem_count];
single_value.value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV_template**)reallocate_pointers((void**)single_value.value_elements, single_value.n_elements, new_size);
single_value.n_elements = new_size;
}
}

int ro__MobileIdentityLV_template::n_elem() const
{
  switch (template_selection) {
  case SPECIFIC_VALUE:
    return single_value.n_elements;
    break;
  case VALUE_LIST:
    return value_list.n_values;
    break;
  default:
    TTCN_error("Performing n_elem");
  }
}

int ro__MobileIdentityLV_template::size_of(boolean is_size) const
{
const char* op_name = is_size ? "size" : "length";
int min_size;
boolean has_any_or_none;
if (is_ifpresent) TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_MobileIdentityLV which has an ifpresent attribute.", op_name);
switch (template_selection)
{
case SPECIFIC_VALUE: {
  min_size = 0;
  has_any_or_none = FALSE;
  int elem_count = single_value.n_elements;
  if (!is_size) { while (elem_count>0 && !single_value.value_elements[elem_count-1]->is_bound()) elem_count--; }
  for (int i=0; i<elem_count; i++) {
    switch (single_value.value_elements[i]->get_selection()) {
    case OMIT_VALUE:
      TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_MobileIdentityLV containing omit element.", op_name);
    case ANY_OR_OMIT:
      has_any_or_none = TRUE;
      break;
    default:
      min_size++;
      break;
    }
  }
} break;
case OMIT_VALUE:
  TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_MobileIdentityLV containing omit value.", op_name);
case ANY_VALUE:
case ANY_OR_OMIT:
  min_size = 0;
  has_any_or_none = TRUE;
  break;
case VALUE_LIST:
{
  if (value_list.n_values<1)
    TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_MobileIdentityLV containing an empty list.", op_name);
  int item_size = value_list.list_value[0].size_of(is_size);
  for (unsigned int i = 1; i < value_list.n_values; i++) {
    if (value_list.list_value[i].size_of(is_size)!=item_size)
      TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_MobileIdentityLV containing a value list with different sizes.", op_name);
  }
  min_size = item_size;
  has_any_or_none = FALSE;
  break;
}
case COMPLEMENTED_LIST:
  TTCN_error("Performing %sof() operation on a template of type @HNBGW_Tests.ro_MobileIdentityLV containing complemented list.", op_name);
default:
  TTCN_error("Performing %sof() operation on an uninitialized/unsupported template of type @HNBGW_Tests.ro_MobileIdentityLV.", op_name);
}
return check_section_is_single(min_size, has_any_or_none, op_name, "a", "template of type @HNBGW_Tests.ro_MobileIdentityLV");
}

boolean ro__MobileIdentityLV_template::match(const ro__MobileIdentityLV& other_value, boolean legacy) const
{
if (!other_value.is_bound()) return FALSE;
int value_length = other_value.size_of();
if (!match_length(value_length)) return FALSE;
switch (template_selection) {
case SPECIFIC_VALUE:
return match_record_of(&other_value, value_length, this, single_value.n_elements, match_function_specific, legacy);
case OMIT_VALUE:
return FALSE;
case ANY_VALUE:
case ANY_OR_OMIT:
return TRUE;
case VALUE_LIST:
case COMPLEMENTED_LIST:
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST;
return template_selection == COMPLEMENTED_LIST;
case CONJUNCTION_MATCH:
for (unsigned int i = 0; i < value_list.n_values; i++) {
if (!value_list.list_value[i].match(other_value)) {
return FALSE;
}
}
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value);
case DYNAMIC_MATCH:
return dyn_match->ptr->match(other_value);
default:
TTCN_error("Matching with an uninitialized/unsupported template of type @HNBGW_Tests.ro_MobileIdentityLV.");
}
return FALSE;
}

boolean ro__MobileIdentityLV_template::is_value() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE;
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
if (!single_value.value_elements[elem_count]->is_value()) return FALSE;
return TRUE;
}

ro__MobileIdentityLV ro__MobileIdentityLV_template::valueof() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of type @HNBGW_Tests.ro_MobileIdentityLV.");
ro__MobileIdentityLV ret_val;
ret_val.set_size(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
if (single_value.value_elements[elem_count]->is_bound()) {
ret_val[elem_count] = single_value.value_elements[elem_count]->valueof();
}
return ret_val;
}

ro__MobileIdentityLV ro__MobileIdentityLV_template::substr(int index, int returncount) const
{
if (!is_value()) TTCN_error("The first argument of function substr() is a template with non-specific value.");
return valueof().substr(index, returncount);
}

ro__MobileIdentityLV ro__MobileIdentityLV_template::replace(int index, int len, const ro__MobileIdentityLV_template& repl) const
{
if (!is_value()) TTCN_error("The first argument of function replace() is a template with non-specific value.");
if (!repl.is_value()) TTCN_error("The fourth argument of function replace() is a template with non-specific value.");
return valueof().replace(index, len, repl.valueof());
}

ro__MobileIdentityLV ro__MobileIdentityLV_template::replace(int index, int len, const ro__MobileIdentityLV& repl) const
{
if (!is_value()) TTCN_error("The first argument of function replace() is a template with non-specific value.");
return valueof().replace(index, len, repl);
}

void ro__MobileIdentityLV_template::set_type(template_sel template_type, unsigned int list_length)
{
clean_up();
switch (template_type) {
case VALUE_LIST:
case COMPLEMENTED_LIST:
case CONJUNCTION_MATCH:
value_list.n_values = list_length;
value_list.list_value = new ro__MobileIdentityLV_template[list_length];
break;
default:
TTCN_error("Internal error: Setting an invalid type for a template of type @HNBGW_Tests.ro_MobileIdentityLV.");
}
set_selection(template_type);
}

ro__MobileIdentityLV_template& ro__MobileIdentityLV_template::list_item(unsigned int list_index)
{
if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST && template_selection != CONJUNCTION_MATCH) TTCN_error("Internal error: Accessing a list element of a non-list template of type @HNBGW_Tests.ro_MobileIdentityLV.");
if (list_index >= value_list.n_values) TTCN_error("Internal error: Index overflow in a value list template of type @HNBGW_Tests.ro_MobileIdentityLV.");
return value_list.list_value[list_index];
}

void ro__MobileIdentityLV_template::log() const
{
switch (template_selection) {
case SPECIFIC_VALUE:
if (single_value.n_elements > 0) {
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
if (permutation_starts_at(elem_count)) TTCN_Logger::log_event_str("permutation(");
single_value.value_elements[elem_count]->log();
if (permutation_ends_at(elem_count)) TTCN_Logger::log_char(')');
}
TTCN_Logger::log_event_str(" }");
} else TTCN_Logger::log_event_str("{ }");
break;
case COMPLEMENTED_LIST:
TTCN_Logger::log_event_str("complement");
case CONJUNCTION_MATCH:
if (template_selection == CONJUNCTION_MATCH) {
TTCN_Logger::log_event_str("conjunct");
}
case VALUE_LIST:
TTCN_Logger::log_char('(');
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) {
if (list_count > 0) TTCN_Logger::log_event_str(", ");
value_list.list_value[list_count].log();
}
TTCN_Logger::log_char(')');
break;
case IMPLICATION_MATCH:
implication_.precondition->log();
TTCN_Logger::log_event_str(" implies ");
implication_.implied_template->log();
break;
case DYNAMIC_MATCH:
TTCN_Logger::log_event_str("@dynamic template");
break;
default:
log_generic();
}
log_restricted();
log_ifpresent();
}

void ro__MobileIdentityLV_template::log_match(const ro__MobileIdentityLV& match_value, boolean legacy) const
{
if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){
if(match(match_value, legacy)){
TTCN_Logger::print_logmatch_buffer();
TTCN_Logger::log_event_str(" matched");
}else{
if (template_selection == SPECIFIC_VALUE && single_value.n_elements > 0 && get_number_of_permutations() == 0 && single_value.n_elements == match_value.size_of()) {
size_t previous_size = TTCN_Logger::get_logmatch_buffer_len();
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if(!single_value.value_elements[elem_count]->match(match_value[elem_count], legacy)){
TTCN_Logger::log_logmatch_info("[%d]", elem_count);
single_value.value_elements[elem_count]->log_match(match_value[elem_count], legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
}
log_match_length(single_value.n_elements);
} else {
TTCN_Logger::print_logmatch_buffer();
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
TTCN_Logger::log_event_str(" unmatched");
}
}
return;
}
if (template_selection == SPECIFIC_VALUE && single_value.n_elements > 0 && get_number_of_permutations() == 0 && single_value.n_elements == match_value.size_of()) {
TTCN_Logger::log_event_str("{ ");
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
single_value.value_elements[elem_count]->log_match(match_value[elem_count], legacy);
}
TTCN_Logger::log_event_str(" }");
log_match_length(single_value.n_elements);
} else {
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched");
else TTCN_Logger::log_event_str(" unmatched");
}
}

void ro__MobileIdentityLV_template::encode_text(Text_Buf& text_buf) const
{
encode_text_permutation(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
text_buf.push_int(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++)
single_value.value_elements[elem_count]->encode_text(text_buf);
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
text_buf.push_int(value_list.n_values);
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].encode_text(text_buf);
break;
default:
TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @HNBGW_Tests.ro_MobileIdentityLV.");
}
}

void ro__MobileIdentityLV_template::decode_text(Text_Buf& text_buf)
{
clean_up();
decode_text_permutation(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value.n_elements = text_buf.pull_int().get_val();
if (single_value.n_elements < 0) TTCN_error("Text decoder: Negative size was received for a template of type @HNBGW_Tests.ro_MobileIdentityLV.");
single_value.value_elements = (MobileL3__CommonIE__Types::MobileIdentityLV_template**)allocate_pointers(single_value.n_elements);
for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) {
single_value.value_elements[elem_count] = new MobileL3__CommonIE__Types::MobileIdentityLV_template;
single_value.value_elements[elem_count]->decode_text(text_buf);
}
case OMIT_VALUE:
case ANY_VALUE:
case ANY_OR_OMIT:
break;
case VALUE_LIST:
case COMPLEMENTED_LIST:
value_list.n_values = text_buf.pull_int().get_val();
value_list.list_value = new ro__MobileIdentityLV_template[value_list.n_values];
for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++)
value_list.list_value[list_count].decode_text(text_buf);
break;
default:
TTCN_error("Text decoder: An unknown/unsupported selection was received for a template of type @HNBGW_Tests.ro_MobileIdentityLV.");
}
}

boolean ro__MobileIdentityLV_template::is_present(boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE;
return !match_omit(legacy);
}

boolean ro__MobileIdentityLV_template::match_omit(boolean legacy) const
{
if (is_ifpresent) return TRUE;
switch (template_selection) {
case OMIT_VALUE:
case ANY_OR_OMIT:
return TRUE;
case IMPLICATION_MATCH:
return !implication_.precondition->match_omit() || implication_.implied_template->match_omit();
case VALUE_LIST:
case COMPLEMENTED_LIST:
if (legacy) {
for (unsigned int i=0; i<value_list.n_values; i++)
if (value_list.list_value[i].match_omit())
return template_selection==VALUE_LIST;
return template_selection==COMPLEMENTED_LIST;
} // else fall through
default:
return FALSE;
}
return FALSE;
}

void ro__MobileIdentityLV_template::set_implicit_omit()
{
if (template_selection != SPECIFIC_VALUE) return;
for (int i = 0; i < single_value.n_elements; i++) {
if (single_value.value_elements[i] != NULL) single_value.value_elements[i]->set_implicit_omit();
}
}

void ro__MobileIdentityLV_template::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_TEMPLATE|Module_Param::BC_LIST, "record of template");
  switch (param.get_type()) {
  case Module_Param::MP_Omit:
    *this = OMIT_VALUE;
    break;
  case Module_Param::MP_Any:
    *this = ANY_VALUE;
    break;
  case Module_Param::MP_AnyOrNone:
    *this = ANY_OR_OMIT;
    break;
  case Module_Param::MP_List_Template:
  case Module_Param::MP_ComplementList_Template:
  case Module_Param::MP_ConjunctList_Template: {
    ro__MobileIdentityLV_template temp;
    temp.set_type(param.get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (param.get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), param.get_size());
    for (size_t p_i=0; p_i<param.get_size(); p_i++) {
      temp.list_item(p_i).set_param(*param.get_elem(p_i));
    }
    *this = temp;
    break; }
  case Module_Param::MP_Indexed_List:
    if (template_selection!=SPECIFIC_VALUE) set_size(0);
    for (size_t p_i=0; p_i<param.get_size(); ++p_i) {
      (*this)[(int)(param.get_elem(p_i)->get_id()->get_index())].set_param(*param.get_elem(p_i));
    }
    break;
  case Module_Param::MP_Value_List: {
    set_size(param.get_size());
    int curr_idx = 0;
    for (size_t p_i=0; p_i<param.get_size(); ++p_i) {
      switch (param.get_elem(p_i)->get_type()) {
      case Module_Param::MP_NotUsed:
        curr_idx++;
        break;
      case Module_Param::MP_Permutation_Template: {
        int perm_start_idx = curr_idx;
        Module_Param* param_i = param.get_elem(p_i);
        for (size_t perm_i=0; perm_i<param_i->get_size(); perm_i++) {
          (*this)[curr_idx].set_param(*(param_i->get_elem(perm_i)));
          curr_idx++;
        }
        int perm_end_idx = curr_idx - 1;
        add_permutation(perm_start_idx, perm_end_idx);
      } break;
      default:
        (*this)[curr_idx].set_param(*param.get_elem(p_i));
        curr_idx++;
      }
    }
  } break;
  case Module_Param::MP_Implication_Template: {
    ro__MobileIdentityLV_template* precondition = new ro__MobileIdentityLV_template;
    precondition->set_param(*param.get_elem(0));
    ro__MobileIdentityLV_template* implied_template = new ro__MobileIdentityLV_template;
    implied_template->set_param(*param.get_elem(1));
    *this = ro__MobileIdentityLV_template(precondition, implied_template);
  } break;
  default:
    param.type_error("record of template", "@HNBGW_Tests.ro_MobileIdentityLV");
  }
  is_ifpresent = param.get_ifpresent();
  set_length_range(param);
}

void ro__MobileIdentityLV_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return;
switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) {
case TR_OMIT:
if (template_selection==OMIT_VALUE) return;
case TR_VALUE:
if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break;
for (int i=0; i<single_value.n_elements; i++) single_value.value_elements[i]->check_restriction(t_res, t_name ? t_name : "@HNBGW_Tests.ro_MobileIdentityLV");
return;
case TR_PRESENT:
if (!match_omit(legacy)) return;
break;
default:
return;
}
TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@HNBGW_Tests.ro_MobileIdentityLV");
}

boolean ro__MobileIdentityLV_template::get_istemplate_kind(const char* type) const {
if (!strcmp(type, "AnyElement")) {
  if (template_selection != SPECIFIC_VALUE) {
    return FALSE;
  }
  for (int i = 0; i < single_value.n_elements; i++) {
    if (single_value.value_elements[i]->get_selection() == ANY_VALUE) {
      return TRUE;
    }
  }
  return FALSE;
} else if (!strcmp(type, "AnyElementsOrNone")) {
  if (template_selection != SPECIFIC_VALUE) {
    return FALSE;
  }
  for (int i = 0; i < single_value.n_elements; i++) {
    if (single_value.value_elements[i]->get_selection() == ANY_OR_OMIT) {
      return TRUE;
    }
  }
  return FALSE;
} else if (!strcmp(type, "permutation")) {
  return number_of_permutations;
} else if (!strcmp(type, "length")) {
  return length_restriction_type != NO_LENGTH_RESTRICTION;
} else {
  return Base_Template::get_istemplate_kind(type);
}
}

/* Bodies of functions, altsteps and testcases */

INTEGER f__cn__idx(const BOOLEAN& ps__domain, const INTEGER& cn__nr)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 94, TTCN_Location::LOCATION_FUNCTION, "f_cn_idx");
current_location.update_lineno(96);
/* HNBGW_Tests.ttcn, line 96 */
if (ps__domain) {
current_location.update_lineno(97);
/* HNBGW_Tests.ttcn, line 97 */
return (4 + cn__nr);
}
current_location.update_lineno(99);
/* HNBGW_Tests.ttcn, line 99 */
return (0 + cn__nr);
}

RANAP__PDU__Descriptions::RANAP__PDU_template MSC__UnitdataCallback(const RANAP__PDU__Descriptions::RANAP__PDU& ranap)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 137, TTCN_Location::LOCATION_FUNCTION, "MSC_UnitdataCallback");
current_location.update_lineno(139);
/* HNBGW_Tests.ttcn, line 139 */
try {
TTCN_Logger::begin_event(TTCN_USER);
TTCN_Logger::log_event_str("MSC_UnitdataCallback: Ignoring RANAP msg: ");
ranap.log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
current_location.update_lineno(140);
/* HNBGW_Tests.ttcn, line 140 */
return RANAP__PDU__Descriptions::RANAP__PDU_template(OMIT_VALUE);
}

void start_MSC__UnitdataCallback(const COMPONENT& component_reference, const RANAP__PDU__Descriptions::RANAP__PDU& ranap)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function MSC_UnitdataCallback(");
ranap.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "MSC_UnitdataCallback", text_buf);
ranap.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

alt_status as__Tguard_instance(boolean first_alt_run)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 196, TTCN_Location::LOCATION_ALTSTEP, "as_Tguard");
alt_status ret_val = ALT_NO;
current_location.update_lineno(197);
/* HNBGW_Tests.ttcn, line 197 */
switch (test__CT_component_T__guard.timeout(NULL)) {
case ALT_YES:
{
current_location.update_lineno(198);
/* HNBGW_Tests.ttcn, line 198 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Timeout of T_guard"),TTCN_Logger::end_event_log2str()));
current_location.update_lineno(199);
/* HNBGW_Tests.ttcn, line 199 */
TTCN_Runtime::stop_component(MTC_COMPREF);
}
case ALT_MAYBE:
ret_val = ALT_MAYBE;
default:
break;
}
return ret_val;
}

void as__Tguard(boolean nodefault_modifier)
{
altstep_begin:
boolean block_flag = FALSE;
alt_status altstep_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
for ( ; ; ) {
TTCN_Snapshot::take_new(block_flag);
if (altstep_flag != ALT_NO) {
altstep_flag = as__Tguard_instance(!block_flag);
if (altstep_flag == ALT_YES || altstep_flag == ALT_BREAK) return;
else if (altstep_flag == ALT_REPEAT) goto altstep_begin;
}
if (!nodefault_modifier && default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(!block_flag);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) return;
else if (default_flag == ALT_REPEAT) goto altstep_begin;
}
if (altstep_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in altstep as_Tguard.");
else block_flag = TRUE;
}
}

Default_Base *activate_as__Tguard()
{
return new as__Tguard_Default();
}

void f__init__vty(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 203, TTCN_Location::LOCATION_FUNCTION, "f_init_vty");
current_location.update_lineno(204);
/* HNBGW_Tests.ttcn, line 204 */
if (test__CT_component_HNBGWVTY.check_port_state(cs_5)) {
current_location.update_lineno(206);
/* HNBGW_Tests.ttcn, line 206 */
return;
}
current_location.update_lineno(208);
/* HNBGW_Tests.ttcn, line 208 */
{
Map_Params tmp_0(0);
TTCN_Runtime::map_port(self, test__CT_component_HNBGWVTY.get_name(), SYSTEM_COMPREF, "HNBGWVTY", tmp_0);
}
current_location.update_lineno(209);
/* HNBGW_Tests.ttcn, line 209 */
Osmocom__VTY__Functions::f__vty__set__prompts(test__CT_component_HNBGWVTY, Osmocom__VTY__Functions::f__vty__set__prompts_prompt__prefix_defval);
current_location.update_lineno(210);
/* HNBGW_Tests.ttcn, line 210 */
Osmocom__VTY__Functions::f__vty__transceive(test__CT_component_HNBGWVTY, cs_6, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

void start_f__init__vty(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_vty(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_init_vty", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__init__vty__stp()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 213, TTCN_Location::LOCATION_FUNCTION, "f_init_vty_stp");
current_location.update_lineno(214);
/* HNBGW_Tests.ttcn, line 214 */
if (test__CT_component_STPVTY.check_port_state(cs_5)) {
current_location.update_lineno(216);
/* HNBGW_Tests.ttcn, line 216 */
return;
}
current_location.update_lineno(218);
/* HNBGW_Tests.ttcn, line 218 */
{
Map_Params tmp_1(0);
TTCN_Runtime::map_port(self, test__CT_component_STPVTY.get_name(), SYSTEM_COMPREF, "STPVTY", tmp_1);
}
current_location.update_lineno(219);
/* HNBGW_Tests.ttcn, line 219 */
Osmocom__VTY__Functions::f__vty__set__prompts(test__CT_component_STPVTY, cs_7);
current_location.update_lineno(220);
/* HNBGW_Tests.ttcn, line 220 */
Osmocom__VTY__Functions::f__vty__transceive(test__CT_component_STPVTY, cs_6, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

void start_f__init__vty__stp(const COMPONENT& component_reference)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_vty_stp(");
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_init_vty_stp", text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__vty__stp__hnbgw__asp__cmd(const CHARSTRING& cmd)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 223, TTCN_Location::LOCATION_FUNCTION, "f_vty_stp_hnbgw_asp_cmd");
current_location.update_lineno(225);
/* HNBGW_Tests.ttcn, line 225 */
CHARSTRING asp__node(cs_8);
current_location.update_lineno(226);
/* HNBGW_Tests.ttcn, line 226 */
{
Osmocom__VTY__Functions::rof__charstring tmp_2;
tmp_2.set_size(2);
tmp_2[0] = cs_9;
tmp_2[1] = asp__node;
Osmocom__VTY__Functions::f__vty__config2(test__CT_component_STPVTY, tmp_2, cmd);
}
}

void start_f__vty__stp__hnbgw__asp__cmd(const COMPONENT& component_reference, const CHARSTRING& cmd)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_vty_stp_hnbgw_asp_cmd(");
cmd.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_vty_stp_hnbgw_asp_cmd", text_buf);
cmd.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__init__mgcp(const CHARSTRING& id)
{
CHARSTRING id_shadow(id);
TTCN_Location current_location("HNBGW_Tests.ttcn", 229, TTCN_Location::LOCATION_FUNCTION, "f_init_mgcp");
current_location.update_lineno(230);
/* HNBGW_Tests.ttcn, line 230 */
{
CHARSTRING tmp_3;
tmp_3 = (id_shadow + cs_10);
id_shadow = tmp_3;
}
current_location.update_lineno(231);
/* HNBGW_Tests.ttcn, line 231 */
MGCP__Emulation::MGCPOps ops;
ops.create__cb() = &MGCP__Emulation::ExpectedCreateCallback;
ops.unitdata__cb() = &MGCP__Emulation::DummyUnitdataCallback;
current_location.update_lineno(235);
/* HNBGW_Tests.ttcn, line 235 */
MGCP__Emulation::MGCP__conn__parameters pars;
pars.callagent__ip() = mp__hnbgw__ip;
pars.callagent__udp__port() = -1;
pars.mgw__ip() = mp__mgw__ip;
pars.mgw__udp__port() = mp__mgw__port;
pars.multi__conn__mode() = FALSE;
current_location.update_lineno(243);
/* HNBGW_Tests.ttcn, line 243 */
test__CT_component_vc__MGCP = TTCN_Runtime::create_component("MGCP_Emulation", "MGCP_Emulation_CT", id_shadow, NULL, TRUE);
current_location.update_lineno(244);
/* HNBGW_Tests.ttcn, line 244 */
{
Map_Params tmp_5(0);
TTCN_Runtime::map_port(test__CT_component_vc__MGCP, MGCP__Emulation::MGCP__Emulation__CT_component_MGCP.get_name(), SYSTEM_COMPREF, "MGCP_CODEC_PT", tmp_5);
}
current_location.update_lineno(245);
/* HNBGW_Tests.ttcn, line 245 */
MGCP__Emulation::start_main_(test__CT_component_vc__MGCP, ops, pars, id_shadow);
}

void start_f__init__mgcp(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_mgcp(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_init_mgcp", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

BOOLEAN f__statsd__pfcp__associated()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 248, TTCN_Location::LOCATION_FUNCTION, "f_statsd_pfcp_associated");
current_location.update_lineno(250);
/* HNBGW_Tests.ttcn, line 250 */
CHARSTRING key__name((mp__statsd__prefix + cs_11));
current_location.update_lineno(251);
/* HNBGW_Tests.ttcn, line 251 */
StatsD__Checker::StatsDMetricKeys statsd__keys;
statsd__keys.set_size(1);
statsd__keys[0] = StatsD__Checker::ts__StatsDMetricKey(CHARSTRING_template(key__name), CHARSTRING_template(cs_12)).valueof();
current_location.update_lineno(252);
/* HNBGW_Tests.ttcn, line 252 */
StatsD__Types::StatsDMetrics statsd__snapshot;
current_location.update_lineno(253);
/* HNBGW_Tests.ttcn, line 253 */
BOOLEAN pfcp__associated;
current_location.update_lineno(255);
/* HNBGW_Tests.ttcn, line 255 */
statsd__snapshot = StatsD__Checker::f__statsd__snapshot(statsd__keys, FALSE);
current_location.update_lineno(256);
/* HNBGW_Tests.ttcn, line 256 */
pfcp__associated = (const_cast< const StatsD__Types::StatsDMetrics&>(statsd__snapshot)[0].val() == 1);
current_location.update_lineno(258);
/* HNBGW_Tests.ttcn, line 258 */
return pfcp__associated;
}

void start_f__statsd__pfcp__associated(const COMPONENT& component_reference)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_statsd_pfcp_associated(");
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_statsd_pfcp_associated", text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__pfcp__wait__assoc__setup__req(const BOOLEAN& fail__timeout)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 261, TTCN_Location::LOCATION_FUNCTION, "f_pfcp_wait_assoc_setup_req");
current_location.update_lineno(262);
/* HNBGW_Tests.ttcn, line 262 */
PFCP__Types::PDU__PFCP m;
current_location.update_lineno(263);
/* HNBGW_Tests.ttcn, line 263 */
TIMER T("T", 1.6e1);
current_location.update_lineno(265);
/* HNBGW_Tests.ttcn, line 265 */
PFCP__Emulation::f__PFCPEM__subscribe__bcast();
current_location.update_lineno(267);
/* HNBGW_Tests.ttcn, line 267 */
T.start();
current_location.update_lineno(268);
/* HNBGW_Tests.ttcn, line 268 */
{
tmp_8:
alt_status tmp_8_alt_flag_0 = ALT_MAYBE;
alt_status tmp_8_alt_flag_1 = ALT_MAYBE;
alt_status tmp_8_alt_flag_2 = ALT_UNCHECKED;
alt_status tmp_8_alt_flag_3 = ALT_UNCHECKED;
alt_status tmp_8_default_flag = ALT_MAYBE;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (tmp_8_alt_flag_0 == ALT_MAYBE) {
current_location.update_lineno(269);
/* HNBGW_Tests.ttcn, line 269 */
tmp_8_alt_flag_0 = PFCP__Emulation::PFCP__ConnHdlr_component_PFCP.receive(PFCP__Templates::tr__PFCP__Assoc__Setup__Req(PFCP__Templates::tr__PFCP__Assoc__Setup__Req_node__id_defval), &(m), any_compref, NULL, NULL, NULL);
if (tmp_8_alt_flag_0 == ALT_YES) {
current_location.update_lineno(270);
/* HNBGW_Tests.ttcn, line 270 */
PFCP__Emulation::PFCP__ConnHdlr_component_PFCP.send(PFCP__Templates::ts__PFCP__Assoc__Setup__Resp(const_cast< const PFCP__Types::PDU__PFCP&>(m).sequence__number(), PFCP__Templates::ts__PFCP__Node__ID__fqdn(mp__pfcp__upf__node__id), PFCP__Templates::ts__PFCP__Cause(PFCP__Templates::e__PFCP__Cause::REQUEST__ACCEPTED), 1234), FALSE, NULL);
current_location.update_lineno(272);
/* HNBGW_Tests.ttcn, line 272 */
TTCN_Runtime::setverdict(PASS);
break;
}
}
if (tmp_8_alt_flag_1 == ALT_MAYBE) {
current_location.update_lineno(274);
/* HNBGW_Tests.ttcn, line 274 */
tmp_8_alt_flag_1 = PFCP__Emulation::PFCP__ConnHdlr_component_PFCP.receive(PFCP__Types::PDU__PFCP_template(ANY_VALUE), NULL, any_compref, NULL, NULL, NULL);
if (tmp_8_alt_flag_1 == ALT_YES) {
current_location.update_lineno(275);
/* HNBGW_Tests.ttcn, line 275 */
Misc__Helpers::f__shutdown(cs_13, 275, FAIL, (TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Got an unexpected PFCP message, was waiting for "),PFCP__Templates::tr__PFCP__Assoc__Setup__Req(PFCP__Templates::tr__PFCP__Assoc__Setup__Req_node__id_defval).log(),TTCN_Logger::end_event_log2str()));
break;
}
}
if (tmp_8_alt_flag_2 == ALT_UNCHECKED) {
current_location.update_lineno(278);
/* HNBGW_Tests.ttcn, line 278 */
if (fail__timeout) tmp_8_alt_flag_2 = ALT_MAYBE;
else tmp_8_alt_flag_2 = ALT_NO;
}
if (tmp_8_alt_flag_2 == ALT_MAYBE) {
current_location.update_lineno(278);
/* HNBGW_Tests.ttcn, line 278 */
tmp_8_alt_flag_2 = T.timeout(NULL);
if (tmp_8_alt_flag_2 == ALT_YES) {
current_location.update_lineno(279);
/* HNBGW_Tests.ttcn, line 279 */
Misc__Helpers::f__shutdown(cs_13, 279, FAIL, (TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Timeout waiting for PFCP "),PFCP__Templates::tr__PFCP__Assoc__Setup__Req(PFCP__Templates::tr__PFCP__Assoc__Setup__Req_node__id_defval).log(),TTCN_Logger::end_event_log2str()));
break;
}
}
if (tmp_8_alt_flag_3 == ALT_UNCHECKED) {
current_location.update_lineno(282);
/* HNBGW_Tests.ttcn, line 282 */
if ((!(fail__timeout))) tmp_8_alt_flag_3 = ALT_MAYBE;
else tmp_8_alt_flag_3 = ALT_NO;
}
if (tmp_8_alt_flag_3 == ALT_MAYBE) {
current_location.update_lineno(282);
/* HNBGW_Tests.ttcn, line 282 */
tmp_8_alt_flag_3 = T.timeout(NULL);
if (tmp_8_alt_flag_3 == ALT_YES) {
current_location.update_lineno(283);
/* HNBGW_Tests.ttcn, line 283 */
try {
TTCN_Logger::begin_event(TTCN_USER);
TTCN_Logger::log_event_str("Timeout waiting for PFCP ");
PFCP__Templates::tr__PFCP__Assoc__Setup__Req(PFCP__Templates::tr__PFCP__Assoc__Setup__Req_node__id_defval).log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
break;
}
}
if (tmp_8_default_flag == ALT_MAYBE) {
tmp_8_default_flag = TTCN_Default::try_altsteps(first_run);
if (tmp_8_default_flag == ALT_YES || tmp_8_default_flag == ALT_BREAK) break;
else if (tmp_8_default_flag == ALT_REPEAT) goto tmp_8;
}
current_location.update_lineno(268);
/* HNBGW_Tests.ttcn, line 268 */
if (tmp_8_alt_flag_0 == ALT_NO && tmp_8_alt_flag_1 == ALT_NO && tmp_8_alt_flag_2 == ALT_NO && tmp_8_alt_flag_3 == ALT_NO && tmp_8_default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in the alt statement in file HNBGW_Tests.ttcn between lines 268 and 285.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(286);
/* HNBGW_Tests.ttcn, line 286 */
T.stop();
current_location.update_lineno(288);
/* HNBGW_Tests.ttcn, line 288 */
PFCP__Emulation::f__PFCPEM__unsubscribe__bcast();
}

void start_f__pfcp__wait__assoc__setup__req(const COMPONENT& component_reference, const BOOLEAN& fail__timeout)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_pfcp_wait_assoc_setup_req(");
fail__timeout.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_pfcp_wait_assoc_setup_req", text_buf);
fail__timeout.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__init__pfcp(const CHARSTRING& id)
{
CHARSTRING id_shadow(id);
TTCN_Location current_location("HNBGW_Tests.ttcn", 291, TTCN_Location::LOCATION_FUNCTION, "f_init_pfcp");
current_location.update_lineno(292);
/* HNBGW_Tests.ttcn, line 292 */
{
CHARSTRING tmp_9;
tmp_9 = (id_shadow + cs_14);
id_shadow = tmp_9;
}
current_location.update_lineno(294);
/* HNBGW_Tests.ttcn, line 294 */
PFCP__Emulation::PFCP__Emulation__Cfg pfcp__cfg;
pfcp__cfg.pfcp__bind__ip() = mp__pfcp__ip__local;
pfcp__cfg.pfcp__bind__port() = PFCP__Emulation::PFCP__PORT;
pfcp__cfg.pfcp__remote__ip() = mp__pfcp__ip__remote;
pfcp__cfg.pfcp__remote__port() = PFCP__Emulation::PFCP__PORT;
pfcp__cfg.role() = PFCP__Emulation::PFCP__Role::UPF;
current_location.update_lineno(302);
/* HNBGW_Tests.ttcn, line 302 */
test__CT_component_vc__PFCP = TTCN_Runtime::create_component("PFCP_Emulation", "PFCP_Emulation_CT", id_shadow, NULL, TRUE);
current_location.update_lineno(303);
/* HNBGW_Tests.ttcn, line 303 */
PFCP__Emulation::start_main_(test__CT_component_vc__PFCP, pfcp__cfg);
current_location.update_lineno(305);
/* HNBGW_Tests.ttcn, line 305 */
if ((!(mp__enable__pfcp__tests))) {
current_location.update_lineno(306);
/* HNBGW_Tests.ttcn, line 306 */
return;
}
current_location.update_lineno(310);
/* HNBGW_Tests.ttcn, line 310 */
TTCN_Runtime::connect_port(self, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
current_location.update_lineno(312);
/* HNBGW_Tests.ttcn, line 312 */
if ((!(f__statsd__pfcp__associated()))) {
current_location.update_lineno(313);
/* HNBGW_Tests.ttcn, line 313 */
TTCN_Runtime::connect_port(self, PFCP__Emulation::PFCP__ConnHdlr_component_PFCP.get_name(), test__CT_component_vc__PFCP, PFCP__Emulation::PFCP__Emulation__CT_component_CLIENT.get_name());
current_location.update_lineno(314);
/* HNBGW_Tests.ttcn, line 314 */
TTCN_Runtime::connect_port(self, PFCP__Emulation::PFCP__ConnHdlr_component_PFCP__PROC.get_name(), test__CT_component_vc__PFCP, PFCP__Emulation::PFCP__Emulation__CT_component_CLIENT__PROC.get_name());
current_location.update_lineno(315);
/* HNBGW_Tests.ttcn, line 315 */
f__pfcp__wait__assoc__setup__req(TRUE);
current_location.update_lineno(316);
/* HNBGW_Tests.ttcn, line 316 */
TTCN_Runtime::disconnect_port(self, PFCP__Emulation::PFCP__ConnHdlr_component_PFCP.get_name(), test__CT_component_vc__PFCP, PFCP__Emulation::PFCP__Emulation__CT_component_CLIENT.get_name());
current_location.update_lineno(317);
/* HNBGW_Tests.ttcn, line 317 */
TTCN_Runtime::disconnect_port(self, PFCP__Emulation::PFCP__ConnHdlr_component_PFCP__PROC.get_name(), test__CT_component_vc__PFCP, PFCP__Emulation::PFCP__Emulation__CT_component_CLIENT__PROC.get_name());
}
current_location.update_lineno(320);
/* HNBGW_Tests.ttcn, line 320 */
TTCN_Runtime::disconnect_port(self, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
}

void start_f__init__pfcp(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_pfcp(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_init_pfcp", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__init__hnodeb(const CHARSTRING& id, const INTEGER& hnb__idx, const RUA__Emulation::RuaOps& rua__ops)
{
CHARSTRING id_shadow(id);
TTCN_Location current_location("HNBGW_Tests.ttcn", 323, TTCN_Location::LOCATION_FUNCTION, "f_init_hnodeb");
current_location.update_lineno(324);
/* HNBGW_Tests.ttcn, line 324 */
{
CHARSTRING tmp_11;
tmp_11 = ((id_shadow + cs_15) + int2str(hnb__idx));
id_shadow = tmp_11;
}
current_location.update_lineno(327);
/* HNBGW_Tests.ttcn, line 327 */
Iuh__Emulation::Iuh__conn__parameters iuh__pars;
current_location.update_lineno(328);
/* HNBGW_Tests.ttcn, line 328 */
iuh__pars.remote__ip() = mp__hnbgw__ip;
current_location.update_lineno(329);
/* HNBGW_Tests.ttcn, line 329 */
iuh__pars.remote__sctp__port() = mp__hnbgw__iuh__port;
current_location.update_lineno(330);
/* HNBGW_Tests.ttcn, line 330 */
iuh__pars.local__ip() = mp__hnodeb__ip;
current_location.update_lineno(331);
/* HNBGW_Tests.ttcn, line 331 */
iuh__pars.local__sctp__port() = (mp__hnodeb__port + hnb__idx);
current_location.update_lineno(332);
/* HNBGW_Tests.ttcn, line 332 */
test__CT_component_vc__Iuh[hnb__idx] = TTCN_Runtime::create_component("Iuh_Emulation", "Iuh_Emulation_CT", id_shadow, NULL, TRUE);
current_location.update_lineno(333);
/* HNBGW_Tests.ttcn, line 333 */
TTCN_Runtime::connect_port(self, test__CT_component_HNBAP[hnb__idx].get_name(), const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__Iuh)[hnb__idx], Iuh__Emulation::Iuh__Emulation__CT_component_HNBAP.get_name());
current_location.update_lineno(335);
/* HNBGW_Tests.ttcn, line 335 */
test__CT_component_vc__RUA[hnb__idx] = TTCN_Runtime::create_component("RUA_Emulation", "RUA_Emulation_CT", (id_shadow + cs_16), NULL, TRUE);
current_location.update_lineno(336);
/* HNBGW_Tests.ttcn, line 336 */
TTCN_Runtime::connect_port(const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__RUA)[hnb__idx], RUA__Emulation::RUA__Emulation__CT_component_RUA.get_name(), const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__Iuh)[hnb__idx], Iuh__Emulation::Iuh__Emulation__CT_component_RUA.get_name());
current_location.update_lineno(339);
/* HNBGW_Tests.ttcn, line 339 */
Iuh__Emulation::start_main_(const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__Iuh)[hnb__idx], iuh__pars, id_shadow);
current_location.update_lineno(340);
/* HNBGW_Tests.ttcn, line 340 */
RUA__Emulation::start_main_(const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__RUA)[hnb__idx], rua__ops, (id_shadow + cs_16));
}

void start_f__init__hnodeb(const COMPONENT& component_reference, const CHARSTRING& id, const INTEGER& hnb__idx, const RUA__Emulation::RuaOps& rua__ops)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_hnodeb(");
id.log();
TTCN_Logger::log_event_str(", ");
hnb__idx.log();
TTCN_Logger::log_event_str(", ");
rua__ops.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_init_hnodeb", text_buf);
id.encode_text(text_buf);
hnb__idx.encode_text(text_buf);
rua__ops.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__drop__hnodeb(const INTEGER& hnb__idx)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 343, TTCN_Location::LOCATION_FUNCTION, "f_drop_hnodeb");
current_location.update_lineno(346);
/* HNBGW_Tests.ttcn, line 346 */
const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__Iuh)[hnb__idx].kill();
current_location.update_lineno(347);
/* HNBGW_Tests.ttcn, line 347 */
const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__RUA)[hnb__idx].kill();
current_location.update_lineno(348);
/* HNBGW_Tests.ttcn, line 348 */
TTCN_Runtime::disconnect_port(self, test__CT_component_HNBAP[hnb__idx].get_name(), const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__Iuh)[hnb__idx], Iuh__Emulation::Iuh__Emulation__CT_component_HNBAP.get_name());
current_location.update_lineno(349);
/* HNBGW_Tests.ttcn, line 349 */
TTCN_Runtime::disconnect_port(const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__RUA)[hnb__idx], RUA__Emulation::RUA__Emulation__CT_component_RUA.get_name(), const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__Iuh)[hnb__idx], Iuh__Emulation::Iuh__Emulation__CT_component_RUA.get_name());
}

void start_f__drop__hnodeb(const COMPONENT& component_reference, const INTEGER& hnb__idx)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_drop_hnodeb(");
hnb__idx.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_drop_hnodeb", text_buf);
hnb__idx.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__vty__cnlink__allow__attach(TELNETasp__PortType::TELNETasp__PT& pt, const BOOLEAN& ps__domain, const BooleanList& allow__attach__list)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 354, TTCN_Location::LOCATION_FUNCTION, "f_vty_cnlink_allow_attach");
current_location.update_lineno(356);
/* HNBGW_Tests.ttcn, line 356 */
CHARSTRING config(Osmocom__VTY__Functions::f__vty__transceive__ret(pt, cs_17, Osmocom__VTY__Functions::f__vty__transceive__ret_strict_defval));
current_location.update_lineno(358);
/* HNBGW_Tests.ttcn, line 358 */
CHARSTRING msc__sgsn;
current_location.update_lineno(359);
/* HNBGW_Tests.ttcn, line 359 */
if (ps__domain) {
current_location.update_lineno(360);
/* HNBGW_Tests.ttcn, line 360 */
msc__sgsn = cs_18;
}
else {
current_location.update_lineno(362);
/* HNBGW_Tests.ttcn, line 362 */
msc__sgsn = cs_19;
}
current_location.update_lineno(365);
/* HNBGW_Tests.ttcn, line 365 */
Osmocom__VTY__Functions::f__vty__enter__config(pt);
{
current_location.update_lineno(366);
/* HNBGW_Tests.ttcn, line 366 */
INTEGER cn__nr(0);
current_location.update_lineno(366);
/* HNBGW_Tests.ttcn, line 366 */
for ( ; ; ) {
current_location.update_lineno(366);
/* HNBGW_Tests.ttcn, line 366 */
if (!(cn__nr < allow__attach__list.size_of())) break;
{
current_location.update_lineno(367);
/* HNBGW_Tests.ttcn, line 367 */
if ((TCCConversion__Functions::f__strstr(config, ((((cs_20 + msc__sgsn) + cs_21) + int2str(cn__nr)) + cs_20), TCCConversion__Functions::f__strstr_offset_defval) < 0)) {
current_location.update_lineno(370);
/* HNBGW_Tests.ttcn, line 370 */
try {
TTCN_Logger::begin_event(TTCN_USER);
msc__sgsn.log();
cn__nr.log();
TTCN_Logger::log_event_str(" is not configured, skipping");
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
current_location.update_lineno(371);
/* HNBGW_Tests.ttcn, line 371 */
goto tmp_20;
}
current_location.update_lineno(373);
/* HNBGW_Tests.ttcn, line 373 */
Osmocom__VTY__Functions::f__vty__transceive(pt, ((msc__sgsn + cs_21) + int2str(cn__nr)), Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(375);
/* HNBGW_Tests.ttcn, line 375 */
if (const_cast< const BooleanList&>(allow__attach__list)[cn__nr]) {
current_location.update_lineno(377);
/* HNBGW_Tests.ttcn, line 377 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_22, FALSE);
}
else {
current_location.update_lineno(379);
/* HNBGW_Tests.ttcn, line 379 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_23, FALSE);
}
current_location.update_lineno(381);
/* HNBGW_Tests.ttcn, line 381 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_24, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}
tmp_20:
current_location.update_lineno(366);
/* HNBGW_Tests.ttcn, line 366 */
{
INTEGER tmp_21;
++cn__nr;
}
}
}
current_location.update_lineno(383);
/* HNBGW_Tests.ttcn, line 383 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_24, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

void f__cn__nr__init(const BOOLEAN& ps__domain, const INTEGER& cn__nr)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 390, TTCN_Location::LOCATION_FUNCTION, "f_cn_nr_init");
current_location.update_lineno(391);
/* HNBGW_Tests.ttcn, line 391 */
RAN__Emulation::RanOps ranops(test__CT_component_g__ran__ops);
current_location.update_lineno(392);
/* HNBGW_Tests.ttcn, line 392 */
ranops.ps__domain() = ps__domain;
current_location.update_lineno(393);
/* HNBGW_Tests.ttcn, line 393 */
INTEGER cn__idx(f__cn__idx(ps__domain, cn__nr));
current_location.update_lineno(394);
/* HNBGW_Tests.ttcn, line 394 */
CHARSTRING msc__sgsn(cs_19);
current_location.update_lineno(395);
/* HNBGW_Tests.ttcn, line 395 */
if (ps__domain) {
current_location.update_lineno(396);
/* HNBGW_Tests.ttcn, line 396 */
msc__sgsn = cs_18;
}
current_location.update_lineno(398);
/* HNBGW_Tests.ttcn, line 398 */
RAN__Adapter::f__ran__adapter__init(test__CT_component_g__cn[cn__idx], const_cast< const RAN__Adapter::RAN__Configurations&>(mp__cn__cfg)[cn__idx], ((cs_25 + msc__sgsn) + int2str(cn__nr)), ranops);
current_location.update_lineno(399);
/* HNBGW_Tests.ttcn, line 399 */
RAN__Adapter::f__ran__adapter__start(test__CT_component_g__cn[cn__idx]);
}

void start_f__cn__nr__init(const COMPONENT& component_reference, const BOOLEAN& ps__domain, const INTEGER& cn__nr)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_cn_nr_init(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
cn__nr.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_cn_nr_init", text_buf);
ps__domain.encode_text(text_buf);
cn__nr.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__cn__idx__disconnect(const INTEGER& cn__idx)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 402, TTCN_Location::LOCATION_FUNCTION, "f_cn_idx_disconnect");
current_location.update_lineno(403);
/* HNBGW_Tests.ttcn, line 403 */
RAN__Adapter::f__ran__adapter__cleanup(test__CT_component_g__cn[cn__idx]);
}

void start_f__cn__idx__disconnect(const COMPONENT& component_reference, const INTEGER& cn__idx)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_cn_idx_disconnect(");
cn__idx.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_cn_idx_disconnect", text_buf);
cn__idx.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__init(const CHARSTRING& id, const FLOAT& guard__timeout, const INTEGER& nr__msc, const INTEGER& nr__sgsn, const BOOLEAN& start__hnb)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 407, TTCN_Location::LOCATION_FUNCTION, "f_init");
current_location.update_lineno(410);
/* HNBGW_Tests.ttcn, line 410 */
test__CT_component_T__guard.start(guard__timeout);
current_location.update_lineno(411);
/* HNBGW_Tests.ttcn, line 411 */
activate_as__Tguard();
current_location.update_lineno(413);
/* HNBGW_Tests.ttcn, line 413 */
test__CT_component_vc__mutex__disp = Mutex::f__MutexDisp__start();
current_location.update_lineno(415);
/* HNBGW_Tests.ttcn, line 415 */
StatsD__Checker::f__init__statsd(cs_27, test__CT_component_vc__STATSD, mp__local__statsd__ip, mp__local__statsd__port, test__CT_component_g__statd__timeout);
current_location.update_lineno(416);
/* HNBGW_Tests.ttcn, line 416 */
f__init__vty(cs_27);
current_location.update_lineno(417);
/* HNBGW_Tests.ttcn, line 417 */
Osmocom__CTRL__Adapter::f__ipa__ctrl__start__client(mp__hnbgw__ip, mp__hnbgw__ctrl__port);
current_location.update_lineno(419);
/* HNBGW_Tests.ttcn, line 419 */
f__init__pfcp(id);
current_location.update_lineno(422);
/* HNBGW_Tests.ttcn, line 422 */
RUA__Emulation::RuaOps rua__ops;
rua__ops.create__cb() = &IuhRanapCreateCallback;
rua__ops.unitdata__cb() = &IuhRanapUnitdataCallback;
{
current_location.update_lineno(426);
/* HNBGW_Tests.ttcn, line 426 */
INTEGER i(0);
current_location.update_lineno(426);
/* HNBGW_Tests.ttcn, line 426 */
for ( ; ; ) {
current_location.update_lineno(426);
/* HNBGW_Tests.ttcn, line 426 */
if (!(i < test__CT_component_g__num__hnbs)) break;
current_location.update_lineno(427);
/* HNBGW_Tests.ttcn, line 427 */
{
ConnHdlr::HnbConfig& tmp_26 = test__CT_component_g__hnb__cfg[i]; /* 7388 */
{
GSM__Types::LocationAreaIdentification& tmp_27 = tmp_26.lai();
tmp_27.mcc__mnc() = hs_0;
tmp_27.lac() = (2342 + i);
}
tmp_26.rac() = (11 + i);
tmp_26.sac() = 55;
tmp_26.cell__id() = (1 + i);
}
current_location.update_lineno(436);
/* HNBGW_Tests.ttcn, line 436 */
f__init__hnodeb(TTCN_Runtime::get_testcasename(), i, rua__ops);
current_location.update_lineno(426);
/* HNBGW_Tests.ttcn, line 426 */
{
INTEGER tmp_28;
++i;
}
}
}
{
current_location.update_lineno(442);
/* HNBGW_Tests.ttcn, line 442 */
INTEGER i(0);
current_location.update_lineno(442);
/* HNBGW_Tests.ttcn, line 442 */
for ( ; ; ) {
current_location.update_lineno(442);
/* HNBGW_Tests.ttcn, line 442 */
if (!(i < 4)) break;
current_location.update_lineno(443);
/* HNBGW_Tests.ttcn, line 443 */
Osmocom__VTY__Functions::f__vty__transceive(test__CT_component_HNBGWVTY, ((cs_28 + int2str(i)) + cs_29), FALSE);
current_location.update_lineno(442);
/* HNBGW_Tests.ttcn, line 442 */
{
INTEGER tmp_29;
++i;
}
}
}
current_location.update_lineno(446);
/* HNBGW_Tests.ttcn, line 446 */
BooleanList allow__attach;
allow__attach.set_size(4);
allow__attach[0] = FALSE;
allow__attach[1] = FALSE;
allow__attach[2] = FALSE;
allow__attach[3] = FALSE;
{
current_location.update_lineno(447);
/* HNBGW_Tests.ttcn, line 447 */
INTEGER i(0);
current_location.update_lineno(447);
/* HNBGW_Tests.ttcn, line 447 */
for ( ; ; ) {
current_location.update_lineno(447);
/* HNBGW_Tests.ttcn, line 447 */
if (!(i < nr__msc)) break;
current_location.update_lineno(448);
/* HNBGW_Tests.ttcn, line 448 */
INTEGER cn__idx((0 + i));
current_location.update_lineno(449);
/* HNBGW_Tests.ttcn, line 449 */
allow__attach[i] = TRUE;
current_location.update_lineno(450);
/* HNBGW_Tests.ttcn, line 450 */
f__cn__nr__init(FALSE, i);
current_location.update_lineno(447);
/* HNBGW_Tests.ttcn, line 447 */
{
INTEGER tmp_31;
++i;
}
}
}
current_location.update_lineno(453);
/* HNBGW_Tests.ttcn, line 453 */
f__vty__cnlink__allow__attach(test__CT_component_HNBGWVTY, FALSE, allow__attach);
{
current_location.update_lineno(458);
/* HNBGW_Tests.ttcn, line 458 */
INTEGER i(0);
current_location.update_lineno(458);
/* HNBGW_Tests.ttcn, line 458 */
for ( ; ; ) {
current_location.update_lineno(458);
/* HNBGW_Tests.ttcn, line 458 */
if (!(i < 4)) break;
current_location.update_lineno(459);
/* HNBGW_Tests.ttcn, line 459 */
Osmocom__VTY__Functions::f__vty__transceive(test__CT_component_HNBGWVTY, ((cs_30 + int2str(i)) + cs_29), FALSE);
current_location.update_lineno(458);
/* HNBGW_Tests.ttcn, line 458 */
{
INTEGER tmp_32;
++i;
}
}
}
current_location.update_lineno(462);
/* HNBGW_Tests.ttcn, line 462 */
allow__attach.set_size(4);
allow__attach[0] = FALSE;
allow__attach[1] = FALSE;
allow__attach[2] = FALSE;
allow__attach[3] = FALSE;
{
current_location.update_lineno(463);
/* HNBGW_Tests.ttcn, line 463 */
INTEGER i(0);
current_location.update_lineno(463);
/* HNBGW_Tests.ttcn, line 463 */
for ( ; ; ) {
current_location.update_lineno(463);
/* HNBGW_Tests.ttcn, line 463 */
if (!(i < nr__sgsn)) break;
current_location.update_lineno(464);
/* HNBGW_Tests.ttcn, line 464 */
INTEGER cn__idx((4 + i));
current_location.update_lineno(465);
/* HNBGW_Tests.ttcn, line 465 */
allow__attach[i] = TRUE;
current_location.update_lineno(466);
/* HNBGW_Tests.ttcn, line 466 */
f__cn__nr__init(TRUE, i);
current_location.update_lineno(463);
/* HNBGW_Tests.ttcn, line 463 */
{
INTEGER tmp_35;
++i;
}
}
}
current_location.update_lineno(468);
/* HNBGW_Tests.ttcn, line 468 */
f__vty__cnlink__allow__attach(test__CT_component_HNBGWVTY, TRUE, allow__attach);
current_location.update_lineno(470);
/* HNBGW_Tests.ttcn, line 470 */
f__init__mgcp(id);
current_location.update_lineno(472);
/* HNBGW_Tests.ttcn, line 472 */
if (start__hnb) {
current_location.update_lineno(473);
/* HNBGW_Tests.ttcn, line 473 */
f__start__hnbs();
}
current_location.update_lineno(479);
/* HNBGW_Tests.ttcn, line 479 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__init(const COMPONENT& component_reference, const CHARSTRING& id, const FLOAT& guard__timeout, const INTEGER& nr__msc, const INTEGER& nr__sgsn, const BOOLEAN& start__hnb)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init(");
id.log();
TTCN_Logger::log_event_str(", ");
guard__timeout.log();
TTCN_Logger::log_event_str(", ");
nr__msc.log();
TTCN_Logger::log_event_str(", ");
nr__sgsn.log();
TTCN_Logger::log_event_str(", ");
start__hnb.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_init", text_buf);
id.encode_text(text_buf);
guard__timeout.encode_text(text_buf);
nr__msc.encode_text(text_buf);
nr__sgsn.encode_text(text_buf);
start__hnb.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__shutdown__helper()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 482, TTCN_Location::LOCATION_FUNCTION, "f_shutdown_helper");
current_location.update_lineno(483);
/* HNBGW_Tests.ttcn, line 483 */
if (mp__validate__talloc__asn1) {
current_location.update_lineno(484);
/* HNBGW_Tests.ttcn, line 484 */
{
Misc__Helpers::ro__charstring tmp_36;
tmp_36.set_size(1);
tmp_36[0] = cs_31;
Osmocom__VTY__Functions::f__verify__talloc__bytes(test__CT_component_HNBGWVTY, tmp_36, 1, Osmocom__VTY__Functions::f__verify__talloc__bytes_attempts_defval, Osmocom__VTY__Functions::f__verify__talloc__bytes_wait__time_defval);
}
}
current_location.update_lineno(487);
/* HNBGW_Tests.ttcn, line 487 */
TTCN_Runtime::stop_component(ALL_COMPREF);
current_location.update_lineno(488);
/* HNBGW_Tests.ttcn, line 488 */
TTCN_Runtime::setverdict(PASS);
current_location.update_lineno(489);
/* HNBGW_Tests.ttcn, line 489 */
TTCN_Runtime::stop_component(MTC_COMPREF);
}

void start_f__shutdown__helper(const COMPONENT& component_reference)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_shutdown_helper(");
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_shutdown_helper", text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__start__hnbs()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 493, TTCN_Location::LOCATION_FUNCTION, "f_start_hnbs");
{
current_location.update_lineno(494);
/* HNBGW_Tests.ttcn, line 494 */
INTEGER i(0);
current_location.update_lineno(494);
/* HNBGW_Tests.ttcn, line 494 */
for ( ; ; ) {
current_location.update_lineno(494);
/* HNBGW_Tests.ttcn, line 494 */
if (!(i < test__CT_component_g__num__hnbs)) break;
current_location.update_lineno(495);
/* HNBGW_Tests.ttcn, line 495 */
f__hnbap__hnb__register(i, f__hnbap__hnb__register_expect__reject_defval);
current_location.update_lineno(494);
/* HNBGW_Tests.ttcn, line 494 */
{
INTEGER tmp_37;
++i;
}
}
}
}

void start_f__start__hnbs(const COMPONENT& component_reference)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_start_hnbs(");
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_start_hnbs", text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

CHARSTRING f__hnb__ctr__prefix(const ConnHdlr::HnbConfig& hnb__cfg)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 499, TTCN_Location::LOCATION_FUNCTION, "f_hnb_ctr_prefix");
current_location.update_lineno(501);
/* HNBGW_Tests.ttcn, line 501 */
HEXSTRING mcc;
current_location.update_lineno(502);
/* HNBGW_Tests.ttcn, line 502 */
HEXSTRING mnc;
current_location.update_lineno(503);
/* HNBGW_Tests.ttcn, line 503 */
{
HEXSTRING tmp_38;
HEXSTRING tmp_39;
GSM__Types::f__dec__mcc__mnc(hex2oct(const_cast< const ConnHdlr::HnbConfig&>(hnb__cfg).lai().mcc__mnc()), tmp_38, tmp_39);
if (tmp_38.is_bound()) mcc = tmp_38;
if (tmp_39.is_bound()) mnc = tmp_39;
}
current_location.update_lineno(504);
/* HNBGW_Tests.ttcn, line 504 */
return (((((((((((((((((mp__statsd__prefix + cs_32) + hex2str(mcc)) + cs_33) + hex2str(mnc)) + cs_33) + cs_34) + int2str(const_cast< const ConnHdlr::HnbConfig&>(hnb__cfg).lai().lac())) + cs_33) + cs_35) + int2str(const_cast< const ConnHdlr::HnbConfig&>(hnb__cfg).rac())) + cs_33) + cs_36) + int2str(const_cast< const ConnHdlr::HnbConfig&>(hnb__cfg).sac())) + cs_33) + cs_37) + int2str(const_cast< const ConnHdlr::HnbConfig&>(hnb__cfg).cell__id())) + cs_38);
}

ConnHdlr::TestHdlrParams f__TestHdlrParams(const INTEGER& imsi__suffix, const BOOLEAN& ps__domain, const BOOLEAN& expect__separate__sccp__cr, const INTEGER& tx__sccp__cr__data__len, const BOOLEAN& expect__compl__l3__success, const INTEGER& cn__nr, const RANAP__IEs::Cause_template& rab__rel__cause)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 516, TTCN_Location::LOCATION_FUNCTION, "f_TestHdlrParams");
current_location.update_lineno(524);
/* HNBGW_Tests.ttcn, line 524 */
ConnHdlr::TestHdlrParams_template pars;
current_location.update_lineno(525);
/* HNBGW_Tests.ttcn, line 525 */
ConnHdlr::MgcpParameters_template mgcp__pars;
current_location.update_lineno(526);
/* HNBGW_Tests.ttcn, line 526 */
ConnHdlr::PfcpParameters_template pfcp__pars;
current_location.update_lineno(527);
/* HNBGW_Tests.ttcn, line 527 */
mgcp__pars = ConnHdlr::t__MgcpParams(imsi__suffix);
current_location.update_lineno(528);
/* HNBGW_Tests.ttcn, line 528 */
pfcp__pars = ConnHdlr::t__PfcpParams(mp__enable__pfcp__tests, mp__pfcp__ip__local, mp__pfcp__upf__node__id, (1000 + imsi__suffix));
current_location.update_lineno(532);
/* HNBGW_Tests.ttcn, line 532 */
pars = ConnHdlr::t__pars(imsi__suffix, ps__domain, ConnHdlr::t__pars_hnb__idx_defval, expect__separate__sccp__cr, tx__sccp__cr__data__len, expect__compl__l3__success, f__cn__idx(ps__domain, cn__nr), mgcp__pars, pfcp__pars, rab__rel__cause, mp__hnbgw__timer__x31, ConnHdlr::t__pars_t__guard_defval);
current_location.update_lineno(542);
/* HNBGW_Tests.ttcn, line 542 */
pars.sccp__addr__hnbgw() = const_cast< const VALUE_ARRAY<RAN__Adapter::RAN__Adapter, 8, 0>&>(test__CT_component_g__cn)[const_cast< const ConnHdlr::TestHdlrParams_template&>(pars).cn__idx().valueof()].sccpa().sccp__addr__peer();
current_location.update_lineno(543);
/* HNBGW_Tests.ttcn, line 543 */
pars.sccp__addr__msc() = const_cast< const VALUE_ARRAY<RAN__Adapter::RAN__Adapter, 8, 0>&>(test__CT_component_g__cn)[const_cast< const ConnHdlr::TestHdlrParams_template&>(pars).cn__idx().valueof()].sccpa().sccp__addr__own();
current_location.update_lineno(544);
/* HNBGW_Tests.ttcn, line 544 */
return pars.valueof();
}

void start_f__TestHdlrParams(const COMPONENT& component_reference, const INTEGER& imsi__suffix, const BOOLEAN& ps__domain, const BOOLEAN& expect__separate__sccp__cr, const INTEGER& tx__sccp__cr__data__len, const BOOLEAN& expect__compl__l3__success, const INTEGER& cn__nr, const RANAP__IEs::Cause_template& rab__rel__cause)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TestHdlrParams(");
imsi__suffix.log();
TTCN_Logger::log_event_str(", ");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
expect__separate__sccp__cr.log();
TTCN_Logger::log_event_str(", ");
tx__sccp__cr__data__len.log();
TTCN_Logger::log_event_str(", ");
expect__compl__l3__success.log();
TTCN_Logger::log_event_str(", ");
cn__nr.log();
TTCN_Logger::log_event_str(", ");
rab__rel__cause.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TestHdlrParams", text_buf);
imsi__suffix.encode_text(text_buf);
ps__domain.encode_text(text_buf);
expect__separate__sccp__cr.encode_text(text_buf);
tx__sccp__cr__data__len.encode_text(text_buf);
expect__compl__l3__success.encode_text(text_buf);
cn__nr.encode_text(text_buf);
rab__rel__cause.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

COMPONENT IuhRanapCreateCallback(const BITSTRING& , const RUA__IEs::CN__DomainIndicator& , const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 548, TTCN_Location::LOCATION_FUNCTION, "IuhRanapCreateCallback");
current_location.update_lineno(550);
/* HNBGW_Tests.ttcn, line 550 */
TTCN_Logger::log_str(TTCN_USER, "CreateCallback");
current_location.update_lineno(551);
/* HNBGW_Tests.ttcn, line 551 */
return NULL_COMPREF;
}

void start_IuhRanapCreateCallback(const COMPONENT& component_reference, const BITSTRING& context__id, const RUA__IEs::CN__DomainIndicator& domain, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function IuhRanapCreateCallback(");
context__id.log();
TTCN_Logger::log_event_str(", ");
domain.log();
TTCN_Logger::log_event_str(", ");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "IuhRanapCreateCallback", text_buf);
context__id.encode_text(text_buf);
domain.encode_text(text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

RANAP__PDU__Descriptions::RANAP__PDU_template IuhRanapUnitdataCallback(const RANAP__PDU__Descriptions::RANAP__PDU& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 555, TTCN_Location::LOCATION_FUNCTION, "IuhRanapUnitdataCallback");
current_location.update_lineno(557);
/* HNBGW_Tests.ttcn, line 557 */
TTCN_Logger::log_str(TTCN_USER, "UnitdataCallback");
current_location.update_lineno(558);
/* HNBGW_Tests.ttcn, line 558 */
return RANAP__PDU__Descriptions::RANAP__PDU_template(OMIT_VALUE);
}

void start_IuhRanapUnitdataCallback(const COMPONENT& component_reference, const RANAP__PDU__Descriptions::RANAP__PDU& ranap)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function IuhRanapUnitdataCallback(");
ranap.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "IuhRanapUnitdataCallback", text_buf);
ranap.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

COMPONENT f__start__handler__create(const ConnHdlr::TestHdlrParams& pars)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 561, TTCN_Location::LOCATION_FUNCTION, "f_start_handler_create");
current_location.update_lineno(562);
/* HNBGW_Tests.ttcn, line 562 */
COMPONENT vc__conn;
current_location.update_lineno(563);
/* HNBGW_Tests.ttcn, line 563 */
CHARSTRING id((TTCN_Runtime::get_testcasename() + int2str(const_cast< const ConnHdlr::TestHdlrParams&>(pars).hnb__idx())));
current_location.update_lineno(565);
/* HNBGW_Tests.ttcn, line 565 */
vc__conn = TTCN_Runtime::create_component("ConnHdlr", "ConnHdlr", id, NULL, TRUE);
current_location.update_lineno(568);
/* HNBGW_Tests.ttcn, line 568 */
TTCN_Runtime::connect_port(vc__conn, RUA__Emulation::RUA__ConnHdlr_component_RUA.get_name(), const_cast< const VALUE_ARRAY<COMPONENT, 2, 0>&>(test__CT_component_vc__RUA)[const_cast< const ConnHdlr::TestHdlrParams&>(pars).hnb__idx()], RUA__Emulation::RUA__Emulation__CT_component_CLIENT.get_name());
current_location.update_lineno(571);
/* HNBGW_Tests.ttcn, line 571 */
TTCN_Runtime::connect_port(vc__conn, RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.get_name(), const_cast< const VALUE_ARRAY<RAN__Adapter::RAN__Adapter, 8, 0>&>(test__CT_component_g__cn)[const_cast< const ConnHdlr::TestHdlrParams&>(pars).cn__idx()].vc__RAN(), RAN__Emulation::RAN__Emulation__CT_component_CLIENT.get_name());
current_location.update_lineno(572);
/* HNBGW_Tests.ttcn, line 572 */
TTCN_Runtime::connect_port(vc__conn, RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN__PROC.get_name(), const_cast< const VALUE_ARRAY<RAN__Adapter::RAN__Adapter, 8, 0>&>(test__CT_component_g__cn)[const_cast< const ConnHdlr::TestHdlrParams&>(pars).cn__idx()].vc__RAN(), RAN__Emulation::RAN__Emulation__CT_component_PROC.get_name());
current_location.update_lineno(575);
/* HNBGW_Tests.ttcn, line 575 */
TTCN_Runtime::connect_port(vc__conn, MGCP__Emulation::MGCP__ConnHdlr_component_MGCP.get_name(), test__CT_component_vc__MGCP, MGCP__Emulation::MGCP__Emulation__CT_component_MGCP__CLIENT.get_name());
current_location.update_lineno(576);
/* HNBGW_Tests.ttcn, line 576 */
TTCN_Runtime::connect_port(vc__conn, MGCP__Emulation::MGCP__ConnHdlr_component_MGCP__PROC.get_name(), test__CT_component_vc__MGCP, MGCP__Emulation::MGCP__Emulation__CT_component_MGCP__PROC.get_name());
current_location.update_lineno(578);
/* HNBGW_Tests.ttcn, line 578 */
TTCN_Runtime::connect_port(vc__conn, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
current_location.update_lineno(580);
/* HNBGW_Tests.ttcn, line 580 */
TTCN_Runtime::connect_port(vc__conn, PFCP__Emulation::PFCP__ConnHdlr_component_PFCP.get_name(), test__CT_component_vc__PFCP, PFCP__Emulation::PFCP__Emulation__CT_component_CLIENT.get_name());
current_location.update_lineno(581);
/* HNBGW_Tests.ttcn, line 581 */
TTCN_Runtime::connect_port(vc__conn, PFCP__Emulation::PFCP__ConnHdlr_component_PFCP__PROC.get_name(), test__CT_component_vc__PFCP, PFCP__Emulation::PFCP__Emulation__CT_component_CLIENT__PROC.get_name());
current_location.update_lineno(583);
/* HNBGW_Tests.ttcn, line 583 */
Mutex::f__MutexDisp__connect(test__CT_component_vc__mutex__disp, vc__conn);
current_location.update_lineno(585);
/* HNBGW_Tests.ttcn, line 585 */
return vc__conn;
}

void start_f__start__handler__create(const COMPONENT& component_reference, const ConnHdlr::TestHdlrParams& pars)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_start_handler_create(");
pars.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_start_handler_create", text_buf);
pars.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__start__handler__run(const COMPONENT& vc__conn, const ConnHdlr::void__fn& fn, const ConnHdlr::TestHdlrParams& pars)
{
ConnHdlr::TestHdlrParams pars_shadow(pars);
TTCN_Location current_location("HNBGW_Tests.ttcn", 588, TTCN_Location::LOCATION_FUNCTION, "f_start_handler_run");
current_location.update_lineno(589);
/* HNBGW_Tests.ttcn, line 589 */
CHARSTRING id(TTCN_Runtime::get_testcasename());
current_location.update_lineno(590);
/* HNBGW_Tests.ttcn, line 590 */
pars_shadow.hnb() = const_cast< const VALUE_ARRAY<ConnHdlr::HnbConfig, 2, 0>&>(test__CT_component_g__hnb__cfg)[const_cast< const ConnHdlr::TestHdlrParams&>(pars_shadow).hnb__idx()];
current_location.update_lineno(591);
/* HNBGW_Tests.ttcn, line 591 */
ConnHdlr::start_f__handler__init(vc__conn, fn, id, pars_shadow);
}

void start_f__start__handler__run(const COMPONENT& component_reference, const COMPONENT& vc__conn, const ConnHdlr::void__fn& fn, const ConnHdlr::TestHdlrParams& pars)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_start_handler_run(");
vc__conn.log();
TTCN_Logger::log_event_str(", ");
fn.log();
TTCN_Logger::log_event_str(", ");
pars.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_start_handler_run", text_buf);
vc__conn.encode_text(text_buf);
fn.encode_text(text_buf);
pars.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

COMPONENT f__start__handler__with__pars(const ConnHdlr::void__fn& fn, const ConnHdlr::TestHdlrParams_template& pars)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 594, TTCN_Location::LOCATION_FUNCTION, "f_start_handler_with_pars");
current_location.update_lineno(596);
/* HNBGW_Tests.ttcn, line 596 */
COMPONENT vc__conn;
current_location.update_lineno(597);
/* HNBGW_Tests.ttcn, line 597 */
vc__conn = f__start__handler__create(pars.valueof());
current_location.update_lineno(598);
/* HNBGW_Tests.ttcn, line 598 */
f__start__handler__run(vc__conn, fn, pars.valueof());
current_location.update_lineno(599);
/* HNBGW_Tests.ttcn, line 599 */
return vc__conn;
}

void start_f__start__handler__with__pars(const COMPONENT& component_reference, const ConnHdlr::void__fn& fn, const ConnHdlr::TestHdlrParams_template& pars)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_start_handler_with_pars(");
fn.log();
TTCN_Logger::log_event_str(", ");
pars.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_start_handler_with_pars", text_buf);
fn.encode_text(text_buf);
pars.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__ConnHdlrList__all__done(const ConnHdlr::ConnHdlrList& vc__conns)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 603, TTCN_Location::LOCATION_FUNCTION, "f_ConnHdlrList_all_done");
{
current_location.update_lineno(605);
/* HNBGW_Tests.ttcn, line 605 */
INTEGER i(0);
current_location.update_lineno(605);
/* HNBGW_Tests.ttcn, line 605 */
for ( ; ; ) {
current_location.update_lineno(605);
/* HNBGW_Tests.ttcn, line 605 */
if (!(i < vc__conns.lengthof())) break;
current_location.update_lineno(606);
/* HNBGW_Tests.ttcn, line 606 */
{
tmp_48:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = const_cast< const ConnHdlr::ConnHdlrList&>(vc__conns)[i].done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_48;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_48;
}
current_location.update_lineno(606);
/* HNBGW_Tests.ttcn, line 606 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 606.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(605);
/* HNBGW_Tests.ttcn, line 605 */
{
INTEGER tmp_49;
++i;
}
}
}
}

void start_f__ConnHdlrList__all__done(const COMPONENT& component_reference, const ConnHdlr::ConnHdlrList& vc__conns)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ConnHdlrList_all_done(");
vc__conns.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ConnHdlrList_all_done", text_buf);
vc__conns.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__hnbap__hnb__register(const INTEGER& hnb__idx, const BOOLEAN& expect__reject)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 615, TTCN_Location::LOCATION_FUNCTION, "f_hnbap_hnb_register");
current_location.update_lineno(617);
/* HNBGW_Tests.ttcn, line 617 */
TIMER T("T", 2.0);
current_location.update_lineno(619);
/* HNBGW_Tests.ttcn, line 619 */
test__CT_component_HNBAP[hnb__idx].send(HNBAP__Templates::ts__HNBAP__HNBRegisterRequest(OCTETSTRING_template(char2oct((cs_39 + int2str(hnb__idx)))), OCTETSTRING_template(hex2oct(const_cast< const VALUE_ARRAY<ConnHdlr::HnbConfig, 2, 0>&>(test__CT_component_g__hnb__cfg)[hnb__idx].lai().mcc__mnc())), BITSTRING_template(int2bit(const_cast< const VALUE_ARRAY<ConnHdlr::HnbConfig, 2, 0>&>(test__CT_component_g__hnb__cfg)[hnb__idx].cell__id(), 28)), OCTETSTRING_template(int2oct(const_cast< const VALUE_ARRAY<ConnHdlr::HnbConfig, 2, 0>&>(test__CT_component_g__hnb__cfg)[hnb__idx].lai().lac(), 2)), OCTETSTRING_template(int2oct(const_cast< const VALUE_ARRAY<ConnHdlr::HnbConfig, 2, 0>&>(test__CT_component_g__hnb__cfg)[hnb__idx].rac(), 1)), OCTETSTRING_template(int2oct(const_cast< const VALUE_ARRAY<ConnHdlr::HnbConfig, 2, 0>&>(test__CT_component_g__hnb__cfg)[hnb__idx].sac(), 2))), FALSE, NULL);
current_location.update_lineno(626);
/* HNBGW_Tests.ttcn, line 626 */
T.start();
current_location.update_lineno(627);
/* HNBGW_Tests.ttcn, line 627 */
{
tmp_50:
alt_status tmp_50_alt_flag_0 = ALT_MAYBE;
alt_status tmp_50_alt_flag_1 = ALT_MAYBE;
alt_status tmp_50_alt_flag_2 = ALT_MAYBE;
alt_status tmp_50_alt_flag_3 = ALT_MAYBE;
alt_status tmp_50_default_flag = ALT_MAYBE;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (tmp_50_alt_flag_0 == ALT_MAYBE) {
current_location.update_lineno(628);
/* HNBGW_Tests.ttcn, line 628 */
tmp_50_alt_flag_0 = test__CT_component_HNBAP[hnb__idx].receive(HNBAP__Templates::tr__HNBAP__HNBRegisterAccept(INTEGER_template(ANY_VALUE)), NULL, any_compref, NULL, NULL, NULL);
if (tmp_50_alt_flag_0 == ALT_YES) {
current_location.update_lineno(629);
/* HNBGW_Tests.ttcn, line 629 */
if (expect__reject) {
current_location.update_lineno(630);
/* HNBGW_Tests.ttcn, line 630 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Rx HNB Register Accept while expecting reject"),TTCN_Logger::end_event_log2str()));
}
else {
current_location.update_lineno(632);
/* HNBGW_Tests.ttcn, line 632 */
TTCN_Runtime::setverdict(PASS);
}
break;
}
}
if (tmp_50_alt_flag_1 == ALT_MAYBE) {
current_location.update_lineno(635);
/* HNBGW_Tests.ttcn, line 635 */
tmp_50_alt_flag_1 = test__CT_component_HNBAP[hnb__idx].receive(HNBAP__Templates::tr__HNBAP__HNBRegisterReject(HNBAP__IEs::Cause_template(ANY_VALUE)), NULL, any_compref, NULL, NULL, NULL);
if (tmp_50_alt_flag_1 == ALT_YES) {
current_location.update_lineno(636);
/* HNBGW_Tests.ttcn, line 636 */
if (expect__reject) {
current_location.update_lineno(637);
/* HNBGW_Tests.ttcn, line 637 */
TTCN_Runtime::setverdict(PASS);
}
else {
current_location.update_lineno(639);
/* HNBGW_Tests.ttcn, line 639 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Rx HNB Register Reject while expecting accept"),TTCN_Logger::end_event_log2str()));
}
break;
}
}
if (tmp_50_alt_flag_2 == ALT_MAYBE) {
current_location.update_lineno(642);
/* HNBGW_Tests.ttcn, line 642 */
tmp_50_alt_flag_2 = test__CT_component_HNBAP[hnb__idx].receive(Iuh__Emulation::IUHEM__Event_template(ANY_VALUE), NULL, any_compref, NULL, NULL, NULL);
if (tmp_50_alt_flag_2 == ALT_YES) {
current_location.update_lineno(643);
/* HNBGW_Tests.ttcn, line 643 */
goto tmp_50;
}
}
if (tmp_50_alt_flag_3 == ALT_MAYBE) {
current_location.update_lineno(645);
/* HNBGW_Tests.ttcn, line 645 */
tmp_50_alt_flag_3 = T.timeout(NULL);
if (tmp_50_alt_flag_3 == ALT_YES) {
current_location.update_lineno(646);
/* HNBGW_Tests.ttcn, line 646 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Timeout waiting for HNB Register response"),TTCN_Logger::end_event_log2str()));
break;
}
}
if (tmp_50_default_flag == ALT_MAYBE) {
tmp_50_default_flag = TTCN_Default::try_altsteps(first_run);
if (tmp_50_default_flag == ALT_YES || tmp_50_default_flag == ALT_BREAK) break;
else if (tmp_50_default_flag == ALT_REPEAT) goto tmp_50;
}
current_location.update_lineno(627);
/* HNBGW_Tests.ttcn, line 627 */
if (tmp_50_alt_flag_0 == ALT_NO && tmp_50_alt_flag_1 == ALT_NO && tmp_50_alt_flag_2 == ALT_NO && tmp_50_alt_flag_3 == ALT_NO && tmp_50_default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in the alt statement in file HNBGW_Tests.ttcn between lines 627 and 648.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
}

void start_f__hnbap__hnb__register(const COMPONENT& component_reference, const INTEGER& hnb__idx, const BOOLEAN& expect__reject)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_hnbap_hnb_register(");
hnb__idx.log();
TTCN_Logger::log_event_str(", ");
expect__reject.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_hnbap_hnb_register", text_buf);
hnb__idx.encode_text(text_buf);
expect__reject.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__hnbap__ue__register(const INTEGER& hnb__idx, const HNBAP__IEs::UE__Identity_template& ue__id, const BOOLEAN& expect__reject)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 651, TTCN_Location::LOCATION_FUNCTION, "f_hnbap_ue_register");
current_location.update_lineno(653);
/* HNBGW_Tests.ttcn, line 653 */
TIMER T("T", 2.0);
current_location.update_lineno(655);
/* HNBGW_Tests.ttcn, line 655 */
{
HNBAP__IEs::UE__Identity_template tmp_51;
tmp_51 = ue__id;
tmp_51.check_restriction(TR_VALUE);
test__CT_component_HNBAP[hnb__idx].send(HNBAP__Templates::ts__HNBAP__UERegisterRequest(tmp_51), FALSE, NULL);
}
current_location.update_lineno(657);
/* HNBGW_Tests.ttcn, line 657 */
T.start();
current_location.update_lineno(658);
/* HNBGW_Tests.ttcn, line 658 */
{
tmp_52:
alt_status tmp_52_alt_flag_0 = ALT_MAYBE;
alt_status tmp_52_alt_flag_1 = ALT_MAYBE;
alt_status tmp_52_alt_flag_2 = ALT_MAYBE;
alt_status tmp_52_alt_flag_3 = ALT_MAYBE;
alt_status tmp_52_default_flag = ALT_MAYBE;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (tmp_52_alt_flag_0 == ALT_MAYBE) {
current_location.update_lineno(659);
/* HNBGW_Tests.ttcn, line 659 */
tmp_52_alt_flag_0 = test__CT_component_HNBAP[hnb__idx].receive(HNBAP__Templates::tr__HNBAP__UERegisterAccept(ue__id), NULL, any_compref, NULL, NULL, NULL);
if (tmp_52_alt_flag_0 == ALT_YES) {
current_location.update_lineno(660);
/* HNBGW_Tests.ttcn, line 660 */
if (expect__reject) {
current_location.update_lineno(661);
/* HNBGW_Tests.ttcn, line 661 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Rx UE Register Accept while expecting reject"),TTCN_Logger::end_event_log2str()));
}
else {
current_location.update_lineno(663);
/* HNBGW_Tests.ttcn, line 663 */
TTCN_Runtime::setverdict(PASS);
}
break;
}
}
if (tmp_52_alt_flag_1 == ALT_MAYBE) {
current_location.update_lineno(666);
/* HNBGW_Tests.ttcn, line 666 */
tmp_52_alt_flag_1 = test__CT_component_HNBAP[hnb__idx].receive(HNBAP__Templates::tr__HNBAP__UERegisterReject(ue__id, HNBAP__IEs::Cause_template(ANY_VALUE)), NULL, any_compref, NULL, NULL, NULL);
if (tmp_52_alt_flag_1 == ALT_YES) {
current_location.update_lineno(667);
/* HNBGW_Tests.ttcn, line 667 */
if (expect__reject) {
current_location.update_lineno(668);
/* HNBGW_Tests.ttcn, line 668 */
TTCN_Runtime::setverdict(PASS);
}
else {
current_location.update_lineno(670);
/* HNBGW_Tests.ttcn, line 670 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Rx UE Register Reject while expecting accept"),TTCN_Logger::end_event_log2str()));
}
break;
}
}
if (tmp_52_alt_flag_2 == ALT_MAYBE) {
current_location.update_lineno(673);
/* HNBGW_Tests.ttcn, line 673 */
tmp_52_alt_flag_2 = test__CT_component_HNBAP[hnb__idx].receive(Iuh__Emulation::IUHEM__Event_template(ANY_VALUE), NULL, any_compref, NULL, NULL, NULL);
if (tmp_52_alt_flag_2 == ALT_YES) {
current_location.update_lineno(674);
/* HNBGW_Tests.ttcn, line 674 */
goto tmp_52;
}
}
if (tmp_52_alt_flag_3 == ALT_MAYBE) {
current_location.update_lineno(676);
/* HNBGW_Tests.ttcn, line 676 */
tmp_52_alt_flag_3 = T.timeout(NULL);
if (tmp_52_alt_flag_3 == ALT_YES) {
current_location.update_lineno(677);
/* HNBGW_Tests.ttcn, line 677 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Timeout waiting for UE Register response"),TTCN_Logger::end_event_log2str()));
break;
}
}
if (tmp_52_default_flag == ALT_MAYBE) {
tmp_52_default_flag = TTCN_Default::try_altsteps(first_run);
if (tmp_52_default_flag == ALT_YES || tmp_52_default_flag == ALT_BREAK) break;
else if (tmp_52_default_flag == ALT_REPEAT) goto tmp_52;
}
current_location.update_lineno(658);
/* HNBGW_Tests.ttcn, line 658 */
if (tmp_52_alt_flag_0 == ALT_NO && tmp_52_alt_flag_1 == ALT_NO && tmp_52_alt_flag_2 == ALT_NO && tmp_52_alt_flag_3 == ALT_NO && tmp_52_default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in the alt statement in file HNBGW_Tests.ttcn between lines 658 and 679.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
}

void start_f__hnbap__ue__register(const COMPONENT& component_reference, const INTEGER& hnb__idx, const HNBAP__IEs::UE__Identity_template& ue__id, const BOOLEAN& expect__reject)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_hnbap_ue_register(");
hnb__idx.log();
TTCN_Logger::log_event_str(", ");
ue__id.log();
TTCN_Logger::log_event_str(", ");
expect__reject.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_hnbap_ue_register", text_buf);
hnb__idx.encode_text(text_buf);
ue__id.encode_text(text_buf);
expect__reject.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__hnb__register(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 683, TTCN_Location::LOCATION_TESTCASE, "TC_hnb_register");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_hnb_register", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(684);
/* HNBGW_Tests.ttcn, line 684 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(685);
/* HNBGW_Tests.ttcn, line 685 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, FALSE);
current_location.update_lineno(686);
/* HNBGW_Tests.ttcn, line 686 */
f__hnbap__hnb__register(0, f__hnbap__hnb__register_expect__reject_defval);
current_location.update_lineno(687);
/* HNBGW_Tests.ttcn, line 687 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_hnb_register was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__hnb__register__duplicate(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 692, TTCN_Location::LOCATION_TESTCASE, "TC_hnb_register_duplicate");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_hnb_register_duplicate", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(693);
/* HNBGW_Tests.ttcn, line 693 */
test__CT_component_g__num__hnbs = 2;
current_location.update_lineno(694);
/* HNBGW_Tests.ttcn, line 694 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, FALSE);
current_location.update_lineno(698);
/* HNBGW_Tests.ttcn, line 698 */
{
ConnHdlr::HnbConfig tmp_55;
tmp_55 = const_cast< const VALUE_ARRAY<ConnHdlr::HnbConfig, 2, 0>&>(test__CT_component_g__hnb__cfg)[0];
test__CT_component_g__hnb__cfg[1] = tmp_55;
}
current_location.update_lineno(699);
/* HNBGW_Tests.ttcn, line 699 */
f__hnbap__hnb__register(0, f__hnbap__hnb__register_expect__reject_defval);
current_location.update_lineno(700);
/* HNBGW_Tests.ttcn, line 700 */
f__hnbap__hnb__register(1, TRUE);
current_location.update_lineno(702);
/* HNBGW_Tests.ttcn, line 702 */
{
Osmocom__VTY__Functions::StrList tmp_56;
tmp_56.set_size(1);
tmp_56[0] = cs_40;
Osmocom__VTY__Functions::f__verify__talloc__count(test__CT_component_HNBGWVTY, tmp_56, 1, Osmocom__VTY__Functions::f__verify__talloc__count_attempts_defval, Osmocom__VTY__Functions::f__verify__talloc__count_wait__time_defval);
}
current_location.update_lineno(704);
/* HNBGW_Tests.ttcn, line 704 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_hnb_register_duplicate was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__hnb__register__duplicate__reuse__sctp__assoc(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 710, TTCN_Location::LOCATION_TESTCASE, "TC_hnb_register_duplicate_reuse_sctp_assoc");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_hnb_register_duplicate_reuse_sctp_assoc", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(711);
/* HNBGW_Tests.ttcn, line 711 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(712);
/* HNBGW_Tests.ttcn, line 712 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, FALSE);
current_location.update_lineno(713);
/* HNBGW_Tests.ttcn, line 713 */
f__hnbap__hnb__register(0, f__hnbap__hnb__register_expect__reject_defval);
current_location.update_lineno(714);
/* HNBGW_Tests.ttcn, line 714 */
f__hnbap__hnb__register(0, f__hnbap__hnb__register_expect__reject_defval);
current_location.update_lineno(715);
/* HNBGW_Tests.ttcn, line 715 */
{
Osmocom__VTY__Functions::StrList tmp_58;
tmp_58.set_size(1);
tmp_58[0] = cs_40;
Osmocom__VTY__Functions::f__verify__talloc__count(test__CT_component_HNBGWVTY, tmp_58, 1, Osmocom__VTY__Functions::f__verify__talloc__count_attempts_defval, Osmocom__VTY__Functions::f__verify__talloc__count_wait__time_defval);
}
current_location.update_lineno(716);
/* HNBGW_Tests.ttcn, line 716 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_hnb_register_duplicate_reuse_sctp_assoc was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__hnb__reregister__reuse__sctp__assoc(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 721, TTCN_Location::LOCATION_TESTCASE, "TC_hnb_reregister_reuse_sctp_assoc");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_hnb_reregister_reuse_sctp_assoc", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(722);
/* HNBGW_Tests.ttcn, line 722 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(723);
/* HNBGW_Tests.ttcn, line 723 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, FALSE);
current_location.update_lineno(724);
/* HNBGW_Tests.ttcn, line 724 */
f__hnbap__hnb__register(0, f__hnbap__hnb__register_expect__reject_defval);
current_location.update_lineno(725);
/* HNBGW_Tests.ttcn, line 725 */
test__CT_component_HNBAP[0].send(HNBAP__Templates::ts__HNBAP__HNBDe__Register(HNBAP__Templates::ts__HnbapCause(HNBAP__IEs::CauseRadioNetwork_template(HNBAP__IEs::CauseRadioNetwork::unspecified))), FALSE, NULL);
current_location.update_lineno(726);
/* HNBGW_Tests.ttcn, line 726 */
f__hnbap__hnb__register(0, f__hnbap__hnb__register_expect__reject_defval);
current_location.update_lineno(727);
/* HNBGW_Tests.ttcn, line 727 */
{
Osmocom__VTY__Functions::StrList tmp_60;
tmp_60.set_size(1);
tmp_60[0] = cs_40;
Osmocom__VTY__Functions::f__verify__talloc__count(test__CT_component_HNBGWVTY, tmp_60, 1, Osmocom__VTY__Functions::f__verify__talloc__count_attempts_defval, Osmocom__VTY__Functions::f__verify__talloc__count_wait__time_defval);
}
current_location.update_lineno(728);
/* HNBGW_Tests.ttcn, line 728 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_hnb_reregister_reuse_sctp_assoc was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__ctrs__hnb__init(const INTEGER& hnb__start, const INTEGER& hnb__count, const Osmocom__CTRL__Functions::CounterNameVals& counternames)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 736, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_hnb_init");
current_location.update_lineno(738);
/* HNBGW_Tests.ttcn, line 738 */
test__CT_component_g__ctr__hnb = Osmocom__CTRL__Functions::f__counter__name__vals__get__n(Osmocom__CTRL__Adapter::CTRL__Adapter__CT_component_IPA__CTRL, cs_42, hnb__count, counternames, hnb__start);
current_location.update_lineno(739);
/* HNBGW_Tests.ttcn, line 739 */
try {
TTCN_Logger::begin_event(TTCN_USER);
TTCN_Logger::log_event_str("initial hnb rate counters: ");
test__CT_component_g__ctr__hnb.log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
}

void start_f__ctrs__hnb__init(const COMPONENT& component_reference, const INTEGER& hnb__start, const INTEGER& hnb__count, const Osmocom__CTRL__Functions::CounterNameVals& counternames)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_init(");
hnb__start.log();
TTCN_Logger::log_event_str(", ");
hnb__count.log();
TTCN_Logger::log_event_str(", ");
counternames.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_hnb_init", text_buf);
hnb__start.encode_text(text_buf);
hnb__count.encode_text(text_buf);
counternames.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__ctrs__hnb__verify()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 750, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_hnb_verify");
current_location.update_lineno(751);
/* HNBGW_Tests.ttcn, line 751 */
try {
TTCN_Logger::begin_event(TTCN_USER);
TTCN_Logger::log_event_str("verifying hnb rate counters: ");
test__CT_component_g__ctr__hnb.log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
current_location.update_lineno(752);
/* HNBGW_Tests.ttcn, line 752 */
Osmocom__CTRL__Functions::f__counter__name__vals__expect__n(Osmocom__CTRL__Adapter::CTRL__Adapter__CT_component_IPA__CTRL, cs_42, test__CT_component_g__ctr__hnb);
}

void start_f__ctrs__hnb__verify(const COMPONENT& component_reference)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_verify(");
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_hnb_verify", text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__ctrs__hnb__expect(const INTEGER& hnb__nr, const CHARSTRING& countername, const INTEGER& val)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 762, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_hnb_expect");
current_location.update_lineno(763);
/* HNBGW_Tests.ttcn, line 763 */
f__ctrs__hnb__add(hnb__nr, countername, val);
current_location.update_lineno(764);
/* HNBGW_Tests.ttcn, line 764 */
f__ctrs__hnb__verify();
}

void start_f__ctrs__hnb__expect(const COMPONENT& component_reference, const INTEGER& hnb__nr, const CHARSTRING& countername, const INTEGER& val)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_expect(");
hnb__nr.log();
TTCN_Logger::log_event_str(", ");
countername.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_hnb_expect", text_buf);
hnb__nr.encode_text(text_buf);
countername.encode_text(text_buf);
val.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__ctrs__hnb__add(const INTEGER& hnb__nr, const CHARSTRING& countername, const INTEGER& val)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 767, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_hnb_add");
current_location.update_lineno(768);
/* HNBGW_Tests.ttcn, line 768 */
Osmocom__CTRL__Functions::f__counter__name__vals__list__add(test__CT_component_g__ctr__hnb, hnb__nr, countername, val);
}

void start_f__ctrs__hnb__add(const COMPONENT& component_reference, const INTEGER& hnb__nr, const CHARSTRING& countername, const INTEGER& val)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_add(");
hnb__nr.log();
TTCN_Logger::log_event_str(", ");
countername.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_hnb_add", text_buf);
hnb__nr.encode_text(text_buf);
countername.encode_text(text_buf);
val.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__ctrs__hnb__set__all(const INTEGER& hnb__nr, const INTEGER& val)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 773, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_hnb_set_all");
{
current_location.update_lineno(774);
/* HNBGW_Tests.ttcn, line 774 */
INTEGER i(0);
current_location.update_lineno(774);
/* HNBGW_Tests.ttcn, line 774 */
for ( ; ; ) {
current_location.update_lineno(774);
/* HNBGW_Tests.ttcn, line 774 */
if (!(i < 1)) break;
current_location.update_lineno(775);
/* HNBGW_Tests.ttcn, line 775 */
Osmocom__CTRL__Functions::f__counter__name__vals__list__set(test__CT_component_g__ctr__hnb, hnb__nr, counternames__hnb[i].name(), val);
current_location.update_lineno(774);
/* HNBGW_Tests.ttcn, line 774 */
{
INTEGER tmp_63;
++i;
}
}
}
}

void start_f__ctrs__hnb__set__all(const COMPONENT& component_reference, const INTEGER& hnb__nr, const INTEGER& val)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_set_all(");
hnb__nr.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_hnb_set_all", text_buf);
hnb__nr.encode_text(text_buf);
val.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__vty__run__hnbgw(TELNETasp__PortType::TELNETasp__PT& pt, const CHARSTRING& cmd)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 779, TTCN_Location::LOCATION_FUNCTION, "f_vty_run_hnbgw");
current_location.update_lineno(781);
/* HNBGW_Tests.ttcn, line 781 */
Osmocom__VTY__Functions::f__vty__enter__config(pt);
current_location.update_lineno(782);
/* HNBGW_Tests.ttcn, line 782 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_43, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(783);
/* HNBGW_Tests.ttcn, line 783 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cmd, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(784);
/* HNBGW_Tests.ttcn, line 784 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_44, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

verdicttype testcase_TC__hnb__disconnected__timeout(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 787, TTCN_Location::LOCATION_TESTCASE, "TC_hnb_disconnected_timeout");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_hnb_disconnected_timeout", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(788);
/* HNBGW_Tests.ttcn, line 788 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(789);
/* HNBGW_Tests.ttcn, line 789 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, TRUE);
current_location.update_lineno(791);
/* HNBGW_Tests.ttcn, line 791 */
f__vty__run__hnbgw(test__CT_component_HNBGWVTY, cs_45);
current_location.update_lineno(794);
/* HNBGW_Tests.ttcn, line 794 */
f__ctrs__hnb__init(f__ctrs__hnb__init_hnb__start_defval, f__ctrs__hnb__init_hnb__count_defval, f__ctrs__hnb__init_counternames_defval);
current_location.update_lineno(797);
/* HNBGW_Tests.ttcn, line 797 */
f__drop__hnodeb(0);
current_location.update_lineno(798);
/* HNBGW_Tests.ttcn, line 798 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(801);
/* HNBGW_Tests.ttcn, line 801 */
f__ctrs__hnb__verify();
current_location.update_lineno(803);
/* HNBGW_Tests.ttcn, line 803 */
Osmocom__Types::f__sleep(5.0);
current_location.update_lineno(806);
/* HNBGW_Tests.ttcn, line 806 */
f__ctrs__hnb__set__all(0, -1);
current_location.update_lineno(807);
/* HNBGW_Tests.ttcn, line 807 */
f__ctrs__hnb__verify();
current_location.update_lineno(809);
/* HNBGW_Tests.ttcn, line 809 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(812);
/* HNBGW_Tests.ttcn, line 812 */
RUA__Emulation::RuaOps rua__ops;
rua__ops.create__cb() = &IuhRanapCreateCallback;
rua__ops.unitdata__cb() = &IuhRanapUnitdataCallback;
current_location.update_lineno(816);
/* HNBGW_Tests.ttcn, line 816 */
f__init__hnodeb(cs_46, 0, rua__ops);
current_location.update_lineno(819);
/* HNBGW_Tests.ttcn, line 819 */
f__ctrs__hnb__verify();
current_location.update_lineno(821);
/* HNBGW_Tests.ttcn, line 821 */
f__hnbap__hnb__register(0, f__hnbap__hnb__register_expect__reject_defval);
current_location.update_lineno(823);
/* HNBGW_Tests.ttcn, line 823 */
f__ctrs__hnb__set__all(0, 0);
current_location.update_lineno(825);
/* HNBGW_Tests.ttcn, line 825 */
f__ctrs__hnb__add(0, cs_41, 1);
current_location.update_lineno(826);
/* HNBGW_Tests.ttcn, line 826 */
f__ctrs__hnb__verify();
current_location.update_lineno(827);
/* HNBGW_Tests.ttcn, line 827 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(830);
/* HNBGW_Tests.ttcn, line 830 */
f__drop__hnodeb(0);
current_location.update_lineno(831);
/* HNBGW_Tests.ttcn, line 831 */
f__ctrs__hnb__verify();
current_location.update_lineno(832);
/* HNBGW_Tests.ttcn, line 832 */
Osmocom__Types::f__sleep(6.0);
current_location.update_lineno(833);
/* HNBGW_Tests.ttcn, line 833 */
f__ctrs__hnb__set__all(0, -1);
current_location.update_lineno(834);
/* HNBGW_Tests.ttcn, line 834 */
f__ctrs__hnb__verify();
current_location.update_lineno(836);
/* HNBGW_Tests.ttcn, line 836 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_hnb_disconnected_timeout was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ue__register(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 840, TTCN_Location::LOCATION_TESTCASE, "TC_ue_register");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ue_register", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(841);
/* HNBGW_Tests.ttcn, line 841 */
HNBAP__IEs::UE__Identity ue__id;
ue__id.iMSI() = Osmocom__Types::imsi__hex2oct(Osmocom__Types::f__gen__imsi(1));
current_location.update_lineno(842);
/* HNBGW_Tests.ttcn, line 842 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(843);
/* HNBGW_Tests.ttcn, line 843 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, TRUE);
current_location.update_lineno(844);
/* HNBGW_Tests.ttcn, line 844 */
f__hnbap__ue__register(0, HNBAP__IEs::UE__Identity_template(ue__id), f__hnbap__ue__register_expect__reject_defval);
current_location.update_lineno(845);
/* HNBGW_Tests.ttcn, line 845 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ue_register was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ue__register__tmsi__lai(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 849, TTCN_Location::LOCATION_TESTCASE, "TC_ue_register_tmsi_lai");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ue_register_tmsi_lai", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(850);
/* HNBGW_Tests.ttcn, line 850 */
HNBAP__IEs::UE__Identity ue__id;
{
HNBAP__IEs::TMSILAI& tmp_66 = ue__id.tMSILAI();
tmp_66.tMSI() = oct2bit(Osmocom__Types::f__gen__tmsi(0, Osmocom__Types::f__gen__tmsi_nri__v_defval, Osmocom__Types::f__gen__tmsi_nri__bitlen_defval, Osmocom__Types::f__gen__tmsi_base__tmsi_defval));
{
HNBAP__IEs::LAI& tmp_67 = tmp_66.lAI();
tmp_67.pLMNID() = os_0;
tmp_67.lAC() = os_1;
}
}
current_location.update_lineno(854);
/* HNBGW_Tests.ttcn, line 854 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(855);
/* HNBGW_Tests.ttcn, line 855 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, TRUE);
current_location.update_lineno(856);
/* HNBGW_Tests.ttcn, line 856 */
f__hnbap__ue__register(0, HNBAP__IEs::UE__Identity_template(ue__id), f__hnbap__ue__register_expect__reject_defval);
current_location.update_lineno(857);
/* HNBGW_Tests.ttcn, line 857 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ue_register_tmsi_lai was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ue__register__before__hnb__register(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 862, TTCN_Location::LOCATION_TESTCASE, "TC_ue_register_before_hnb_register");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ue_register_before_hnb_register", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(863);
/* HNBGW_Tests.ttcn, line 863 */
HNBAP__IEs::UE__Identity ue__id;
ue__id.iMSI() = Osmocom__Types::imsi__hex2oct(Osmocom__Types::f__gen__imsi(1));
current_location.update_lineno(864);
/* HNBGW_Tests.ttcn, line 864 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(865);
/* HNBGW_Tests.ttcn, line 865 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, FALSE);
current_location.update_lineno(866);
/* HNBGW_Tests.ttcn, line 866 */
f__hnbap__ue__register(0, HNBAP__IEs::UE__Identity_template(ue__id), TRUE);
current_location.update_lineno(867);
/* HNBGW_Tests.ttcn, line 867 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ue_register_before_hnb_register was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__initial__ue(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 875, TTCN_Location::LOCATION_FUNCTION, "f_tc_initial_ue");
current_location.update_lineno(876);
/* HNBGW_Tests.ttcn, line 876 */
RANAP__PDU__Descriptions::RANAP__PDU tx(ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars));
current_location.update_lineno(877);
/* HNBGW_Tests.ttcn, line 877 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
}

void start_f__tc__initial__ue(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_initial_ue(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_initial_ue", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__ranap__cs__initial__ue(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 879, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_cs_initial_ue");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_cs_initial_ue", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(880);
/* HNBGW_Tests.ttcn, line 880 */
COMPONENT vc__conn;
current_location.update_lineno(882);
/* HNBGW_Tests.ttcn, line 882 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(883);
/* HNBGW_Tests.ttcn, line 883 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(885);
/* HNBGW_Tests.ttcn, line 885 */
vc__conn = f__start__handler__with__pars(&f__tc__initial__ue, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(1, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(886);
/* HNBGW_Tests.ttcn, line 886 */
{
tmp_72:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_72;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_72;
}
current_location.update_lineno(886);
/* HNBGW_Tests.ttcn, line 886 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 886.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(888);
/* HNBGW_Tests.ttcn, line 888 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_cs_initial_ue was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ranap__ps__initial__ue(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 890, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_ps_initial_ue");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_ps_initial_ue", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(891);
/* HNBGW_Tests.ttcn, line 891 */
COMPONENT vc__conn;
current_location.update_lineno(893);
/* HNBGW_Tests.ttcn, line 893 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(894);
/* HNBGW_Tests.ttcn, line 894 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(896);
/* HNBGW_Tests.ttcn, line 896 */
vc__conn = f__start__handler__with__pars(&f__tc__initial__ue, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(2, TRUE, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(897);
/* HNBGW_Tests.ttcn, line 897 */
{
tmp_75:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_75;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_75;
}
current_location.update_lineno(897);
/* HNBGW_Tests.ttcn, line 897 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 897.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(899);
/* HNBGW_Tests.ttcn, line 899 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_ps_initial_ue was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__vty__set__sccp__max__optional__data(TELNETasp__PortType::TELNETasp__PT& pt, const INTEGER& val)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 902, TTCN_Location::LOCATION_FUNCTION, "f_vty_set_sccp_max_optional_data");
current_location.update_lineno(904);
/* HNBGW_Tests.ttcn, line 904 */
CHARSTRING valstr;
current_location.update_lineno(905);
/* HNBGW_Tests.ttcn, line 905 */
if ((val < 0)) {
current_location.update_lineno(906);
/* HNBGW_Tests.ttcn, line 906 */
valstr = cs_47;
}
else {
current_location.update_lineno(908);
/* HNBGW_Tests.ttcn, line 908 */
valstr = int2str(val);
}
current_location.update_lineno(910);
/* HNBGW_Tests.ttcn, line 910 */
Osmocom__VTY__Functions::f__vty__enter__config(pt);
current_location.update_lineno(911);
/* HNBGW_Tests.ttcn, line 911 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_9, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(912);
/* HNBGW_Tests.ttcn, line 912 */
Osmocom__VTY__Functions::f__vty__transceive(pt, (cs_48 + valstr), Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(913);
/* HNBGW_Tests.ttcn, line 913 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_44, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

verdicttype testcase_TC__ranap__cs__initial__ue__empty__cr(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 916, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_cs_initial_ue_empty_cr");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_cs_initial_ue_empty_cr", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(917);
/* HNBGW_Tests.ttcn, line 917 */
COMPONENT vc__conn;
current_location.update_lineno(919);
/* HNBGW_Tests.ttcn, line 919 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(920);
/* HNBGW_Tests.ttcn, line 920 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(922);
/* HNBGW_Tests.ttcn, line 922 */
f__vty__set__sccp__max__optional__data(test__CT_component_HNBGWVTY, 0);
current_location.update_lineno(924);
/* HNBGW_Tests.ttcn, line 924 */
vc__conn = f__start__handler__with__pars(&f__tc__initial__ue, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(1, f__TestHdlrParams_ps__domain_defval, TRUE, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(925);
/* HNBGW_Tests.ttcn, line 925 */
{
tmp_80:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_80;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_80;
}
current_location.update_lineno(925);
/* HNBGW_Tests.ttcn, line 925 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 925.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(928);
/* HNBGW_Tests.ttcn, line 928 */
f__vty__set__sccp__max__optional__data(test__CT_component_HNBGWVTY, f__vty__set__sccp__max__optional__data_val_defval);
current_location.update_lineno(930);
/* HNBGW_Tests.ttcn, line 930 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_cs_initial_ue_empty_cr was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ranap__ps__initial__ue__empty__cr(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 932, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_ps_initial_ue_empty_cr");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_ps_initial_ue_empty_cr", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(933);
/* HNBGW_Tests.ttcn, line 933 */
COMPONENT vc__conn;
current_location.update_lineno(935);
/* HNBGW_Tests.ttcn, line 935 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(936);
/* HNBGW_Tests.ttcn, line 936 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(938);
/* HNBGW_Tests.ttcn, line 938 */
f__vty__set__sccp__max__optional__data(test__CT_component_HNBGWVTY, 0);
current_location.update_lineno(940);
/* HNBGW_Tests.ttcn, line 940 */
vc__conn = f__start__handler__with__pars(&f__tc__initial__ue, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(2, TRUE, TRUE, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(941);
/* HNBGW_Tests.ttcn, line 941 */
{
tmp_83:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_83;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_83;
}
current_location.update_lineno(941);
/* HNBGW_Tests.ttcn, line 941 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 941.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(944);
/* HNBGW_Tests.ttcn, line 944 */
f__vty__set__sccp__max__optional__data(test__CT_component_HNBGWVTY, f__vty__set__sccp__max__optional__data_val_defval);
current_location.update_lineno(946);
/* HNBGW_Tests.ttcn, line 946 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_ps_initial_ue_empty_cr was stopped.");
}
return TTCN_Runtime::end_testcase();
}

boolean operator==(null_type, const Testdata__CR__Limits& other_value)
{
if (other_value.val_ptr == NULL)
TTCN_error("The right operand of comparison is an unbound value of type @HNBGW_Tests.Testdata_CR_Limits.");
return other_value.val_ptr->n_elements == 0;
}

verdicttype testcase_TC__sccp__cr__limit(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 956, TTCN_Location::LOCATION_TESTCASE, "TC_sccp_cr_limit");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sccp_cr_limit", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(957);
/* HNBGW_Tests.ttcn, line 957 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(958);
/* HNBGW_Tests.ttcn, line 958 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(960);
/* HNBGW_Tests.ttcn, line 960 */
Testdata__CR__Limits tests;
tests.set_size(6);
{
Testdata__CR__Limit& tmp_85 = tests[0];
tmp_85.data__len() = 128;
tmp_85.max__optional__data() = -1;
tmp_85.expect__separate__sccp__cr() = FALSE;
}
{
Testdata__CR__Limit& tmp_86 = tests[1];
tmp_86.data__len() = 129;
tmp_86.max__optional__data() = -1;
tmp_86.expect__separate__sccp__cr() = TRUE;
}
{
Testdata__CR__Limit& tmp_87 = tests[2];
tmp_87.data__len() = 100;
tmp_87.max__optional__data() = 100;
tmp_87.expect__separate__sccp__cr() = FALSE;
}
{
Testdata__CR__Limit& tmp_88 = tests[3];
tmp_88.data__len() = 101;
tmp_88.max__optional__data() = 100;
tmp_88.expect__separate__sccp__cr() = TRUE;
}
{
Testdata__CR__Limit& tmp_89 = tests[4];
tmp_89.data__len() = 200;
tmp_89.max__optional__data() = 200;
tmp_89.expect__separate__sccp__cr() = FALSE;
}
{
Testdata__CR__Limit& tmp_90 = tests[5];
tmp_90.data__len() = 201;
tmp_90.max__optional__data() = 200;
tmp_90.expect__separate__sccp__cr() = TRUE;
}
current_location.update_lineno(971);
/* HNBGW_Tests.ttcn, line 971 */
INTEGER csps;
current_location.update_lineno(972);
/* HNBGW_Tests.ttcn, line 972 */
csps = 0;
current_location.update_lineno(972);
/* HNBGW_Tests.ttcn, line 972 */
for ( ; ; ) {
current_location.update_lineno(972);
/* HNBGW_Tests.ttcn, line 972 */
if (!(csps < 2)) break;
current_location.update_lineno(973);
/* HNBGW_Tests.ttcn, line 973 */
BOOLEAN ps__domain((csps > 0));
current_location.update_lineno(975);
/* HNBGW_Tests.ttcn, line 975 */
INTEGER i;
current_location.update_lineno(976);
/* HNBGW_Tests.ttcn, line 976 */
i = 0;
current_location.update_lineno(976);
/* HNBGW_Tests.ttcn, line 976 */
for ( ; ; ) {
current_location.update_lineno(976);
/* HNBGW_Tests.ttcn, line 976 */
if (!(i < 6)) break;
current_location.update_lineno(977);
/* HNBGW_Tests.ttcn, line 977 */
Testdata__CR__Limit t(tests[i]);
current_location.update_lineno(978);
/* HNBGW_Tests.ttcn, line 978 */
Osmocom__VTY__Functions::f__logp(test__CT_component_HNBGWVTY, (((((((cs_49 + Osmocom__Types::f__bool2str(ps__domain)) + cs_50) + int2str(const_cast< const Testdata__CR__Limit&>(t).data__len())) + cs_51) + int2str(const_cast< const Testdata__CR__Limit&>(t).max__optional__data())) + cs_52) + Osmocom__Types::f__bool2str(const_cast< const Testdata__CR__Limit&>(t).expect__separate__sccp__cr())));
current_location.update_lineno(985);
/* HNBGW_Tests.ttcn, line 985 */
f__vty__set__sccp__max__optional__data(test__CT_component_HNBGWVTY, const_cast< const Testdata__CR__Limit&>(t).max__optional__data());
current_location.update_lineno(986);
/* HNBGW_Tests.ttcn, line 986 */
COMPONENT vc__conn;
current_location.update_lineno(987);
/* HNBGW_Tests.ttcn, line 987 */
vc__conn = f__start__handler__with__pars(&f__tc__initial__ue, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams((100 + i), ps__domain, const_cast< const Testdata__CR__Limit&>(t).expect__separate__sccp__cr(), const_cast< const Testdata__CR__Limit&>(t).data__len(), f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(992);
/* HNBGW_Tests.ttcn, line 992 */
{
tmp_94:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_94;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_94;
}
current_location.update_lineno(992);
/* HNBGW_Tests.ttcn, line 992 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 992.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(976);
/* HNBGW_Tests.ttcn, line 976 */
{
INTEGER tmp_95;
++i;
}
}
current_location.update_lineno(972);
/* HNBGW_Tests.ttcn, line 972 */
{
INTEGER tmp_96;
++csps;
}
}
current_location.update_lineno(997);
/* HNBGW_Tests.ttcn, line 997 */
f__vty__set__sccp__max__optional__data(test__CT_component_HNBGWVTY, f__vty__set__sccp__max__optional__data_val_defval);
current_location.update_lineno(999);
/* HNBGW_Tests.ttcn, line 999 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sccp_cr_limit was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__rab__assignment(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1002, TTCN_Location::LOCATION_FUNCTION, "f_tc_rab_assignment");
current_location.update_lineno(1003);
/* HNBGW_Tests.ttcn, line 1003 */
CHARSTRING hnb0__ctr__prefix(f__hnb__ctr__prefix(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()));
current_location.update_lineno(1004);
/* HNBGW_Tests.ttcn, line 1004 */
MGCP__Types::MgcpCommand mgcp__cmd;
current_location.update_lineno(1005);
/* HNBGW_Tests.ttcn, line 1005 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1007);
/* HNBGW_Tests.ttcn, line 1007 */
StatsD__Checker::f__statsd__reset();
current_location.update_lineno(1009);
/* HNBGW_Tests.ttcn, line 1009 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1010);
/* HNBGW_Tests.ttcn, line 1010 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1013);
/* HNBGW_Tests.ttcn, line 1013 */
StatsD__Checker::StatsDExpects expect;
expect.set_size(3);
{
StatsD__Checker::StatsDExpect& tmp_98 = expect[0];
tmp_98.name() = (hnb0__ctr__prefix + cs_53);
tmp_98.mtype() = cs_54;
tmp_98.min() = 0;
tmp_98.max() = 0;
}
{
StatsD__Checker::StatsDExpect& tmp_99 = expect[1];
tmp_99.name() = (hnb0__ctr__prefix + cs_55);
tmp_99.mtype() = cs_54;
tmp_99.min() = 0;
tmp_99.max() = 0;
}
{
StatsD__Checker::StatsDExpect& tmp_100 = expect[2];
tmp_100.name() = (hnb0__ctr__prefix + cs_56);
tmp_100.mtype() = cs_54;
tmp_100.min() = 0;
tmp_100.max() = 0;
}
current_location.update_lineno(1018);
/* HNBGW_Tests.ttcn, line 1018 */
StatsD__Checker::f__statsd__expect(expect, StatsD__Checker::f__statsd__expect_wait__converge_defval);
current_location.update_lineno(1020);
/* HNBGW_Tests.ttcn, line 1020 */
ConnHdlr::f__create__rab__cs();
current_location.update_lineno(1022);
/* HNBGW_Tests.ttcn, line 1022 */
expect.set_size(3);
{
StatsD__Checker::StatsDExpect& tmp_102 = expect[0];
tmp_102.name() = (hnb0__ctr__prefix + cs_53);
tmp_102.mtype() = cs_54;
tmp_102.min() = 1;
tmp_102.max() = 1;
}
{
StatsD__Checker::StatsDExpect& tmp_103 = expect[1];
tmp_103.name() = (hnb0__ctr__prefix + cs_55);
tmp_103.mtype() = cs_54;
tmp_103.min() = 1;
tmp_103.max() = 1;
}
{
StatsD__Checker::StatsDExpect& tmp_104 = expect[2];
tmp_104.name() = (hnb0__ctr__prefix + cs_56);
tmp_104.mtype() = cs_54;
tmp_104.min() = 0;
tmp_104.max() = 0;
}
current_location.update_lineno(1027);
/* HNBGW_Tests.ttcn, line 1027 */
StatsD__Checker::f__statsd__expect(expect, StatsD__Checker::f__statsd__expect_wait__converge_defval);
current_location.update_lineno(1029);
/* HNBGW_Tests.ttcn, line 1029 */
ConnHdlr::f__cn__iu__release__procedure(TRUE, ConnHdlr::f__cn__iu__release__procedure_pfcp__teardown_defval);
}

void start_f__tc__rab__assignment(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_assignment(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_rab_assignment", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__rab__assignment(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1031, TTCN_Location::LOCATION_TESTCASE, "TC_rab_assignment");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_rab_assignment", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1032);
/* HNBGW_Tests.ttcn, line 1032 */
COMPONENT vc__conn;
current_location.update_lineno(1033);
/* HNBGW_Tests.ttcn, line 1033 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1034);
/* HNBGW_Tests.ttcn, line 1034 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1036);
/* HNBGW_Tests.ttcn, line 1036 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__assignment, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(3, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1037);
/* HNBGW_Tests.ttcn, line 1037 */
{
tmp_107:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_107;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_107;
}
current_location.update_lineno(1037);
/* HNBGW_Tests.ttcn, line 1037 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1037.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1039);
/* HNBGW_Tests.ttcn, line 1039 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_rab_assignment was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__rab__assignment__concurrent(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1046, TTCN_Location::LOCATION_FUNCTION, "f_tc_rab_assignment_concurrent");
current_location.update_lineno(1047);
/* HNBGW_Tests.ttcn, line 1047 */
CHARSTRING hnb0__ctr__prefix(f__hnb__ctr__prefix(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()));
current_location.update_lineno(1048);
/* HNBGW_Tests.ttcn, line 1048 */
MGCP__Types::MgcpCommand mgcp__cmd;
current_location.update_lineno(1049);
/* HNBGW_Tests.ttcn, line 1049 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1051);
/* HNBGW_Tests.ttcn, line 1051 */
StatsD__Checker::f__statsd__reset();
current_location.update_lineno(1053);
/* HNBGW_Tests.ttcn, line 1053 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1054);
/* HNBGW_Tests.ttcn, line 1054 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1056);
/* HNBGW_Tests.ttcn, line 1056 */
ConnHdlr::f__create__rab__cs();
current_location.update_lineno(1059);
/* HNBGW_Tests.ttcn, line 1059 */
Osmocom__Types::f__sleep(2.0);
current_location.update_lineno(1061);
/* HNBGW_Tests.ttcn, line 1061 */
ConnHdlr::f__cn__iu__release__procedure(TRUE, ConnHdlr::f__cn__iu__release__procedure_pfcp__teardown_defval);
}

void start_f__tc__rab__assignment__concurrent(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_assignment_concurrent(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_rab_assignment_concurrent", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__rab__assignment__concurrent(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1063, TTCN_Location::LOCATION_TESTCASE, "TC_rab_assignment_concurrent");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_rab_assignment_concurrent", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1064);
/* HNBGW_Tests.ttcn, line 1064 */
ConnHdlr::ConnHdlrList vc__conn__list(NULL_VALUE);
current_location.update_lineno(1065);
/* HNBGW_Tests.ttcn, line 1065 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1066);
/* HNBGW_Tests.ttcn, line 1066 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1067);
/* HNBGW_Tests.ttcn, line 1067 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1068);
/* HNBGW_Tests.ttcn, line 1068 */
INTEGER num__conns(16);
{
current_location.update_lineno(1070);
/* HNBGW_Tests.ttcn, line 1070 */
INTEGER i(0);
current_location.update_lineno(1070);
/* HNBGW_Tests.ttcn, line 1070 */
for ( ; ; ) {
current_location.update_lineno(1070);
/* HNBGW_Tests.ttcn, line 1070 */
if (!(i < 16)) break;
current_location.update_lineno(1071);
/* HNBGW_Tests.ttcn, line 1071 */
COMPONENT vc__conn;
current_location.update_lineno(1072);
/* HNBGW_Tests.ttcn, line 1072 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__assignment__concurrent, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(i, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1073);
/* HNBGW_Tests.ttcn, line 1073 */
{
ConnHdlr::ConnHdlrList tmp_111;
{
ConnHdlr::ConnHdlrList tmp_112;
tmp_112.set_size(1);
tmp_112[0] = vc__conn;
tmp_111 = (vc__conn__list + tmp_112);
}
vc__conn__list = tmp_111;
}
current_location.update_lineno(1070);
/* HNBGW_Tests.ttcn, line 1070 */
{
INTEGER tmp_113;
++i;
}
}
}
current_location.update_lineno(1076);
/* HNBGW_Tests.ttcn, line 1076 */
f__ConnHdlrList__all__done(vc__conn__list);
current_location.update_lineno(1077);
/* HNBGW_Tests.ttcn, line 1077 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_rab_assignment_concurrent was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__rab__assign__fail(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1080, TTCN_Location::LOCATION_FUNCTION, "f_tc_rab_assign_fail");
current_location.update_lineno(1081);
/* HNBGW_Tests.ttcn, line 1081 */
CHARSTRING hnb0__ctr__prefix(f__hnb__ctr__prefix(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()));
current_location.update_lineno(1082);
/* HNBGW_Tests.ttcn, line 1082 */
MGCP__Types::MgcpCommand mgcp__cmd;
current_location.update_lineno(1083);
/* HNBGW_Tests.ttcn, line 1083 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1084);
/* HNBGW_Tests.ttcn, line 1084 */
TIMER T("T", 5.0);
current_location.update_lineno(1086);
/* HNBGW_Tests.ttcn, line 1086 */
StatsD__Checker::f__statsd__reset();
current_location.update_lineno(1088);
/* HNBGW_Tests.ttcn, line 1088 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1089);
/* HNBGW_Tests.ttcn, line 1089 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1092);
/* HNBGW_Tests.ttcn, line 1092 */
StatsD__Checker::StatsDExpects expect;
expect.set_size(3);
{
StatsD__Checker::StatsDExpect& tmp_115 = expect[0];
tmp_115.name() = (hnb0__ctr__prefix + cs_53);
tmp_115.mtype() = cs_54;
tmp_115.min() = 0;
tmp_115.max() = 0;
}
{
StatsD__Checker::StatsDExpect& tmp_116 = expect[1];
tmp_116.name() = (hnb0__ctr__prefix + cs_55);
tmp_116.mtype() = cs_54;
tmp_116.min() = 0;
tmp_116.max() = 0;
}
{
StatsD__Checker::StatsDExpect& tmp_117 = expect[2];
tmp_117.name() = (hnb0__ctr__prefix + cs_56);
tmp_117.mtype() = cs_54;
tmp_117.min() = 0;
tmp_117.max() = 0;
}
current_location.update_lineno(1097);
/* HNBGW_Tests.ttcn, line 1097 */
StatsD__Checker::f__statsd__expect(expect, StatsD__Checker::f__statsd__expect_wait__converge_defval);
current_location.update_lineno(1099);
/* HNBGW_Tests.ttcn, line 1099 */
ConnHdlr::f__rab__ass__req__cs();
current_location.update_lineno(1102);
/* HNBGW_Tests.ttcn, line 1102 */
tx = RANAP__Templates::ts__RANAP__RabAssResp(RANAP__Templates::ts__RANAP__RabAssResp_rab__sml_defval, RANAP__Templates::ts__RANAP__RabAssResp_rab__rl_defval, RANAP__Templates::ts__RAB__FL(RANAP__Templates::t__RAB__id(23), RANAP__IEs::Cause_template(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).rab__rel__cause())), RANAP__Templates::ts__RANAP__RabAssResp_exts_defval).valueof();
current_location.update_lineno(1103);
/* HNBGW_Tests.ttcn, line 1103 */
ConnHdlr::f__iuh2iu(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu_exp__rx_defval);
current_location.update_lineno(1105);
/* HNBGW_Tests.ttcn, line 1105 */
expect.set_size(3);
{
StatsD__Checker::StatsDExpect& tmp_120 = expect[0];
tmp_120.name() = (hnb0__ctr__prefix + cs_53);
tmp_120.mtype() = cs_54;
tmp_120.min() = 1;
tmp_120.max() = 1;
}
{
StatsD__Checker::StatsDExpect& tmp_121 = expect[1];
tmp_121.name() = (hnb0__ctr__prefix + cs_55);
tmp_121.mtype() = cs_54;
tmp_121.min() = 0;
tmp_121.max() = 0;
}
{
StatsD__Checker::StatsDExpect& tmp_122 = expect[2];
tmp_122.name() = (hnb0__ctr__prefix + cs_56);
tmp_122.mtype() = cs_54;
tmp_122.min() = 1;
tmp_122.max() = 1;
}
current_location.update_lineno(1110);
/* HNBGW_Tests.ttcn, line 1110 */
StatsD__Checker::f__statsd__expect(expect, StatsD__Checker::f__statsd__expect_wait__converge_defval);
current_location.update_lineno(1113);
/* HNBGW_Tests.ttcn, line 1113 */
T.start();
current_location.update_lineno(1114);
/* HNBGW_Tests.ttcn, line 1114 */
{
tmp_123:
alt_status tmp_123_alt_flag_0 = ALT_MAYBE;
alt_status tmp_123_alt_flag_1 = ALT_MAYBE;
alt_status tmp_123_default_flag = ALT_MAYBE;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (tmp_123_alt_flag_0 == ALT_MAYBE) {
current_location.update_lineno(1115);
/* HNBGW_Tests.ttcn, line 1115 */
tmp_123_alt_flag_0 = ConnHdlr::as__mgcp__dlcx_instance(first_run);
if (tmp_123_alt_flag_0 == ALT_REPEAT) goto tmp_123;
if (tmp_123_alt_flag_0 == ALT_BREAK) break;
if (tmp_123_alt_flag_0 == ALT_YES) break;
}
if (tmp_123_alt_flag_1 == ALT_MAYBE) {
current_location.update_lineno(1116);
/* HNBGW_Tests.ttcn, line 1116 */
tmp_123_alt_flag_1 = T.timeout(NULL);
if (tmp_123_alt_flag_1 == ALT_YES) {
current_location.update_lineno(1117);
/* HNBGW_Tests.ttcn, line 1117 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Timeout waiting for DLCX"),TTCN_Logger::end_event_log2str()));
break;
}
}
if (tmp_123_default_flag == ALT_MAYBE) {
tmp_123_default_flag = TTCN_Default::try_altsteps(first_run);
if (tmp_123_default_flag == ALT_YES || tmp_123_default_flag == ALT_BREAK) break;
else if (tmp_123_default_flag == ALT_REPEAT) goto tmp_123;
}
current_location.update_lineno(1114);
/* HNBGW_Tests.ttcn, line 1114 */
if (tmp_123_alt_flag_0 == ALT_NO && tmp_123_alt_flag_1 == ALT_NO && tmp_123_default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in the alt statement in file HNBGW_Tests.ttcn between lines 1114 and 1119.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1120);
/* HNBGW_Tests.ttcn, line 1120 */
T.stop();
}

void start_f__tc__rab__assign__fail(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_assign_fail(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_rab_assign_fail", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__rab__assign__fail(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1123, TTCN_Location::LOCATION_TESTCASE, "TC_rab_assign_fail");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_rab_assign_fail", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1124);
/* HNBGW_Tests.ttcn, line 1124 */
COMPONENT vc__conn;
current_location.update_lineno(1125);
/* HNBGW_Tests.ttcn, line 1125 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1126);
/* HNBGW_Tests.ttcn, line 1126 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1128);
/* HNBGW_Tests.ttcn, line 1128 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__assign__fail, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(4, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, RANAP__Templates::ts__RanapCause__radio__conn__lost)));
current_location.update_lineno(1129);
/* HNBGW_Tests.ttcn, line 1129 */
{
tmp_126:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_126;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_126;
}
current_location.update_lineno(1129);
/* HNBGW_Tests.ttcn, line 1129 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1129.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1131);
/* HNBGW_Tests.ttcn, line 1131 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_rab_assign_fail was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__rab__release(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1134, TTCN_Location::LOCATION_FUNCTION, "f_tc_rab_release");
current_location.update_lineno(1135);
/* HNBGW_Tests.ttcn, line 1135 */
CHARSTRING hnb0__ctr__prefix(f__hnb__ctr__prefix(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()));
current_location.update_lineno(1136);
/* HNBGW_Tests.ttcn, line 1136 */
MGCP__Types::MgcpCommand mgcp__cmd;
current_location.update_lineno(1137);
/* HNBGW_Tests.ttcn, line 1137 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1138);
/* HNBGW_Tests.ttcn, line 1138 */
TIMER T("T", 1.5e1);
current_location.update_lineno(1140);
/* HNBGW_Tests.ttcn, line 1140 */
StatsD__Checker::f__statsd__reset();
current_location.update_lineno(1142);
/* HNBGW_Tests.ttcn, line 1142 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1143);
/* HNBGW_Tests.ttcn, line 1143 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1145);
/* HNBGW_Tests.ttcn, line 1145 */
ConnHdlr::f__create__rab__cs();
current_location.update_lineno(1147);
/* HNBGW_Tests.ttcn, line 1147 */
CHARSTRING ctr__name;
current_location.update_lineno(1148);
/* HNBGW_Tests.ttcn, line 1148 */
if ((const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).rab__rel__cause() == RANAP__Templates::ts__RanapCause__nas__normal.valueof())) {
current_location.update_lineno(1149);
/* HNBGW_Tests.ttcn, line 1149 */
ctr__name = cs_57;
}
else {
current_location.update_lineno(1151);
/* HNBGW_Tests.ttcn, line 1151 */
ctr__name = cs_58;
}
current_location.update_lineno(1155);
/* HNBGW_Tests.ttcn, line 1155 */
StatsD__Checker::StatsDExpects expect;
expect.set_size(1);
{
StatsD__Checker::StatsDExpect& tmp_130 = expect[0];
tmp_130.name() = (hnb0__ctr__prefix + ctr__name);
tmp_130.mtype() = cs_54;
tmp_130.min() = 0;
tmp_130.max() = 0;
}
current_location.update_lineno(1158);
/* HNBGW_Tests.ttcn, line 1158 */
StatsD__Checker::f__statsd__expect(expect, StatsD__Checker::f__statsd__expect_wait__converge_defval);
current_location.update_lineno(1161);
/* HNBGW_Tests.ttcn, line 1161 */
tx = RANAP__Templates::ts__RANAP__RabAssReq(RANAP__Templates::ts__RANAP__RabAssReq_rab__sml_defval, RANAP__Templates::ts__RAB__RL(RANAP__Templates::t__RAB__id(23), RANAP__IEs::Cause_template(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).rab__rel__cause())), RANAP__Templates::ts__RANAP__RabAssReq_exts_defval).valueof();
current_location.update_lineno(1162);
/* HNBGW_Tests.ttcn, line 1162 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(tx, FALSE, NULL);
current_location.update_lineno(1164);
/* HNBGW_Tests.ttcn, line 1164 */
T.start();
current_location.update_lineno(1166);
/* HNBGW_Tests.ttcn, line 1166 */
{
tmp_132:
alt_status tmp_132_alt_flag_0 = ALT_MAYBE;
alt_status tmp_132_alt_flag_1 = ALT_MAYBE;
alt_status tmp_132_default_flag = ALT_MAYBE;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (tmp_132_alt_flag_0 == ALT_MAYBE) {
current_location.update_lineno(1167);
/* HNBGW_Tests.ttcn, line 1167 */
tmp_132_alt_flag_0 = ConnHdlr::as__mgcp__dlcx_instance(first_run);
if (tmp_132_alt_flag_0 == ALT_REPEAT) goto tmp_132;
if (tmp_132_alt_flag_0 == ALT_BREAK) break;
if (tmp_132_alt_flag_0 == ALT_YES) break;
}
if (tmp_132_alt_flag_1 == ALT_MAYBE) {
current_location.update_lineno(1168);
/* HNBGW_Tests.ttcn, line 1168 */
tmp_132_alt_flag_1 = T.timeout(NULL);
if (tmp_132_alt_flag_1 == ALT_YES) {
current_location.update_lineno(1169);
/* HNBGW_Tests.ttcn, line 1169 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Timeout waiting for DLCX"),TTCN_Logger::end_event_log2str()));
break;
}
}
if (tmp_132_default_flag == ALT_MAYBE) {
tmp_132_default_flag = TTCN_Default::try_altsteps(first_run);
if (tmp_132_default_flag == ALT_YES || tmp_132_default_flag == ALT_BREAK) break;
else if (tmp_132_default_flag == ALT_REPEAT) goto tmp_132;
}
current_location.update_lineno(1166);
/* HNBGW_Tests.ttcn, line 1166 */
if (tmp_132_alt_flag_0 == ALT_NO && tmp_132_alt_flag_1 == ALT_NO && tmp_132_default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in the alt statement in file HNBGW_Tests.ttcn between lines 1166 and 1171.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1172);
/* HNBGW_Tests.ttcn, line 1172 */
T.stop();
current_location.update_lineno(1174);
/* HNBGW_Tests.ttcn, line 1174 */
ConnHdlr::f__rua__expect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx));
current_location.update_lineno(1176);
/* HNBGW_Tests.ttcn, line 1176 */
expect.set_size(1);
{
StatsD__Checker::StatsDExpect& tmp_134 = expect[0];
tmp_134.name() = (hnb0__ctr__prefix + ctr__name);
tmp_134.mtype() = cs_54;
tmp_134.min() = 1;
tmp_134.max() = 1;
}
current_location.update_lineno(1179);
/* HNBGW_Tests.ttcn, line 1179 */
StatsD__Checker::f__statsd__expect(expect, StatsD__Checker::f__statsd__expect_wait__converge_defval);
}

void start_f__tc__rab__release(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_release(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_rab_release", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__rab__release(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1183, TTCN_Location::LOCATION_TESTCASE, "TC_rab_release");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_rab_release", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1184);
/* HNBGW_Tests.ttcn, line 1184 */
COMPONENT vc__conn;
current_location.update_lineno(1185);
/* HNBGW_Tests.ttcn, line 1185 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1186);
/* HNBGW_Tests.ttcn, line 1186 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1188);
/* HNBGW_Tests.ttcn, line 1188 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__release, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(5, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1189);
/* HNBGW_Tests.ttcn, line 1189 */
{
tmp_137:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_137;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_137;
}
current_location.update_lineno(1189);
/* HNBGW_Tests.ttcn, line 1189 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1189.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1191);
/* HNBGW_Tests.ttcn, line 1191 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_rab_release was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__rab__release__abnormal(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1195, TTCN_Location::LOCATION_TESTCASE, "TC_rab_release_abnormal");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_rab_release_abnormal", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1196);
/* HNBGW_Tests.ttcn, line 1196 */
COMPONENT vc__conn;
current_location.update_lineno(1197);
/* HNBGW_Tests.ttcn, line 1197 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1198);
/* HNBGW_Tests.ttcn, line 1198 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1200);
/* HNBGW_Tests.ttcn, line 1200 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__release, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(8, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, RANAP__Templates::ts__RanapCause__radio__conn__lost)));
current_location.update_lineno(1202);
/* HNBGW_Tests.ttcn, line 1202 */
{
tmp_140:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_140;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_140;
}
current_location.update_lineno(1202);
/* HNBGW_Tests.ttcn, line 1202 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1202.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1204);
/* HNBGW_Tests.ttcn, line 1204 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_rab_release_abnormal was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__rab__assign__mgcp__to(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1207, TTCN_Location::LOCATION_FUNCTION, "f_tc_rab_assign_mgcp_to");
current_location.update_lineno(1208);
/* HNBGW_Tests.ttcn, line 1208 */
MGCP__Types::MgcpCommand mgcp__cmd;
current_location.update_lineno(1209);
/* HNBGW_Tests.ttcn, line 1209 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1210);
/* HNBGW_Tests.ttcn, line 1210 */
RANAP__PDU__Contents::_root_RANAP__Containers_ProtocolIE__ContainerPairList_RANAP__PDU__Contents_inst1_template rab__sml;
current_location.update_lineno(1211);
/* HNBGW_Tests.ttcn, line 1211 */
TIMER T("T", 1.5e1);
current_location.update_lineno(1213);
/* HNBGW_Tests.ttcn, line 1213 */
T.start();
current_location.update_lineno(1214);
/* HNBGW_Tests.ttcn, line 1214 */
{
MGCP__Emulation::ExpectCriteria tmp_141;
tmp_141.connid() = OMIT_VALUE;
tmp_141.endpoint() = OMIT_VALUE;
tmp_141.transid() = OMIT_VALUE;
MGCP__Emulation::f__create__mgcp__expect(tmp_141);
}
current_location.update_lineno(1216);
/* HNBGW_Tests.ttcn, line 1216 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1217);
/* HNBGW_Tests.ttcn, line 1217 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1221);
/* HNBGW_Tests.ttcn, line 1221 */
rab__sml = RANAP__Templates::ts__RAB__SML(RANAP__Templates::t__RAB__id(23), RANAP__Templates::f__ts__RAB__TLA(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).mgcp__pars().cn__rtp__ip()), RANAP__Templates::t__RAB__binding__port(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).mgcp__pars().cn__rtp__port()));
current_location.update_lineno(1224);
/* HNBGW_Tests.ttcn, line 1224 */
{
RANAP__PDU__Contents::_root_RANAP__Containers_ProtocolIE__ContainerPairList_RANAP__PDU__Contents_inst1_template tmp_145;
tmp_145 = rab__sml;
tmp_145.check_restriction(TR_OMIT);
tx = RANAP__Templates::ts__RANAP__RabAssReq(tmp_145, RANAP__Templates::ts__RANAP__RabAssReq_rab__rl_defval, RANAP__Templates::ts__RANAP__RabAssReq_exts_defval).valueof();
}
current_location.update_lineno(1225);
/* HNBGW_Tests.ttcn, line 1225 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(tx, FALSE, NULL);
current_location.update_lineno(1228);
/* HNBGW_Tests.ttcn, line 1228 */
{
tmp_146:
alt_status tmp_146_alt_flag_0 = ALT_MAYBE;
alt_status tmp_146_alt_flag_1 = ALT_MAYBE;
alt_status tmp_146_alt_flag_2 = ALT_MAYBE;
alt_status tmp_146_default_flag = ALT_MAYBE;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (tmp_146_alt_flag_0 == ALT_MAYBE) {
current_location.update_lineno(1229);
/* HNBGW_Tests.ttcn, line 1229 */
tmp_146_alt_flag_0 = MGCP__Emulation::MGCP__ConnHdlr_component_MGCP.receive(MGCP__Templates::tr__CRCX(MGCP__Templates::tr__CRCX_ep_defval, MGCP__Templates::tr__CRCX_sdp_defval), &(mgcp__cmd), any_compref, NULL, NULL, NULL);
if (tmp_146_alt_flag_0 == ALT_YES) {
current_location.update_lineno(1230);
/* HNBGW_Tests.ttcn, line 1230 */
try {
TTCN_Logger::begin_event(TTCN_USER);
TTCN_Logger::log_event_str("Ignoreing CRCX1");
mgcp__cmd.log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
current_location.update_lineno(1231);
/* HNBGW_Tests.ttcn, line 1231 */
goto tmp_146;
}
}
if (tmp_146_alt_flag_1 == ALT_MAYBE) {
current_location.update_lineno(1233);
/* HNBGW_Tests.ttcn, line 1233 */
tmp_146_alt_flag_1 = RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.receive(RANAP__Templates::tr__RANAP__IuReleaseRequest(RANAP__IEs::Cause_template(ANY_VALUE), RANAP__Templates::tr__RANAP__IuReleaseRequest_exts_defval), NULL, any_compref, NULL, NULL, NULL);
if (tmp_146_alt_flag_1 == ALT_YES) break;
}
if (tmp_146_alt_flag_2 == ALT_MAYBE) {
current_location.update_lineno(1234);
/* HNBGW_Tests.ttcn, line 1234 */
tmp_146_alt_flag_2 = T.timeout(NULL);
if (tmp_146_alt_flag_2 == ALT_YES) {
current_location.update_lineno(1235);
/* HNBGW_Tests.ttcn, line 1235 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Timeout waiting for IuRelease"),TTCN_Logger::end_event_log2str()));
break;
}
}
if (tmp_146_default_flag == ALT_MAYBE) {
tmp_146_default_flag = TTCN_Default::try_altsteps(first_run);
if (tmp_146_default_flag == ALT_YES || tmp_146_default_flag == ALT_BREAK) break;
else if (tmp_146_default_flag == ALT_REPEAT) goto tmp_146;
}
current_location.update_lineno(1228);
/* HNBGW_Tests.ttcn, line 1228 */
if (tmp_146_alt_flag_0 == ALT_NO && tmp_146_alt_flag_1 == ALT_NO && tmp_146_alt_flag_2 == ALT_NO && tmp_146_default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in the alt statement in file HNBGW_Tests.ttcn between lines 1228 and 1237.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1239);
/* HNBGW_Tests.ttcn, line 1239 */
ConnHdlr::f__cn__iu__release__procedure(ConnHdlr::f__cn__iu__release__procedure_mgcp__teardown_defval, ConnHdlr::f__cn__iu__release__procedure_pfcp__teardown_defval);
}

void start_f__tc__rab__assign__mgcp__to(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_assign_mgcp_to(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_rab_assign_mgcp_to", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__rab__assign__mgcp__to(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1242, TTCN_Location::LOCATION_TESTCASE, "TC_rab_assign_mgcp_to");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_rab_assign_mgcp_to", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1243);
/* HNBGW_Tests.ttcn, line 1243 */
COMPONENT vc__conn;
current_location.update_lineno(1244);
/* HNBGW_Tests.ttcn, line 1244 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1245);
/* HNBGW_Tests.ttcn, line 1245 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1247);
/* HNBGW_Tests.ttcn, line 1247 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__assign__mgcp__to, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(6, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1248);
/* HNBGW_Tests.ttcn, line 1248 */
{
tmp_149:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_149;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_149;
}
current_location.update_lineno(1248);
/* HNBGW_Tests.ttcn, line 1248 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1248.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1250);
/* HNBGW_Tests.ttcn, line 1250 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_rab_assign_mgcp_to was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__rab__assign__mgw__iuup__addr__chg(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1256, TTCN_Location::LOCATION_TESTCASE, "TC_rab_assign_mgw_iuup_addr_chg");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_rab_assign_mgw_iuup_addr_chg", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1257);
/* HNBGW_Tests.ttcn, line 1257 */
COMPONENT vc__conn;
current_location.update_lineno(1258);
/* HNBGW_Tests.ttcn, line 1258 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1259);
/* HNBGW_Tests.ttcn, line 1259 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1260);
/* HNBGW_Tests.ttcn, line 1260 */
ConnHdlr::TestHdlrParams_template pars(f__TestHdlrParams(3, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval));
current_location.update_lineno(1262);
/* HNBGW_Tests.ttcn, line 1262 */
pars.mgcp__pars().mgw__conn__ran().mgw__rtp__ip__mdcx() = cs_59;
current_location.update_lineno(1264);
/* HNBGW_Tests.ttcn, line 1264 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__assignment, pars);
current_location.update_lineno(1265);
/* HNBGW_Tests.ttcn, line 1265 */
{
tmp_153:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_153;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_153;
}
current_location.update_lineno(1265);
/* HNBGW_Tests.ttcn, line 1265 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1265.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1267);
/* HNBGW_Tests.ttcn, line 1267 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_rab_assign_mgw_iuup_addr_chg was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__ranap__bidir(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1271, TTCN_Location::LOCATION_FUNCTION, "f_tc_ranap_bidir");
current_location.update_lineno(1273);
/* HNBGW_Tests.ttcn, line 1273 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars)), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1276);
/* HNBGW_Tests.ttcn, line 1276 */
ConnHdlr::f__iu2iuh(RANAP__Templates::ts__RANAP__DirectTransfer(OCTETSTRING_template(Osmocom__Types::f__rnd__octstring(10)), RANAP__Templates::ts__RANAP__DirectTransfer_sapi_defval, RANAP__Templates::ts__RANAP__DirectTransfer_ies_defval, RANAP__Templates::ts__RANAP__DirectTransfer_exts_defval), ConnHdlr::f__iu2iuh_exp__rx_defval);
current_location.update_lineno(1278);
/* HNBGW_Tests.ttcn, line 1278 */
ConnHdlr::f__iuh2iu(RANAP__Templates::ts__RANAP__DirectTransfer(OCTETSTRING_template(Osmocom__Types::f__rnd__octstring(10)), RANAP__Templates::ts__RANAP__DirectTransfer_sapi_defval, RANAP__Templates::ts__RANAP__DirectTransfer_ies_defval, RANAP__Templates::ts__RANAP__DirectTransfer_exts_defval), ConnHdlr::f__iuh2iu_exp__rx_defval);
current_location.update_lineno(1281);
/* HNBGW_Tests.ttcn, line 1281 */
ConnHdlr::f__iu2iuh(RANAP__Templates::ts__RANAP__CommonId(OCTETSTRING_template(hex2oct(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).imsi())), RANAP__Templates::ts__RANAP__CommonId_exts_defval), ConnHdlr::f__iu2iuh_exp__rx_defval);
}

void start_f__tc__ranap__bidir(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ranap_bidir(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_ranap_bidir", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__ranap__cs__bidir(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1283, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_cs_bidir");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_cs_bidir", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1284);
/* HNBGW_Tests.ttcn, line 1284 */
COMPONENT vc__conn;
current_location.update_lineno(1285);
/* HNBGW_Tests.ttcn, line 1285 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1286);
/* HNBGW_Tests.ttcn, line 1286 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1288);
/* HNBGW_Tests.ttcn, line 1288 */
vc__conn = f__start__handler__with__pars(&f__tc__ranap__bidir, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(3, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1289);
/* HNBGW_Tests.ttcn, line 1289 */
{
tmp_156:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_156;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_156;
}
current_location.update_lineno(1289);
/* HNBGW_Tests.ttcn, line 1289 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1289.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1291);
/* HNBGW_Tests.ttcn, line 1291 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_cs_bidir was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ranap__ps__bidir(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1293, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_ps_bidir");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_ps_bidir", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1294);
/* HNBGW_Tests.ttcn, line 1294 */
COMPONENT vc__conn;
current_location.update_lineno(1295);
/* HNBGW_Tests.ttcn, line 1295 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1296);
/* HNBGW_Tests.ttcn, line 1296 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1298);
/* HNBGW_Tests.ttcn, line 1298 */
vc__conn = f__start__handler__with__pars(&f__tc__ranap__bidir, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(4, TRUE, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1299);
/* HNBGW_Tests.ttcn, line 1299 */
{
tmp_159:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_159;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_159;
}
current_location.update_lineno(1299);
/* HNBGW_Tests.ttcn, line 1299 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1299.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1301);
/* HNBGW_Tests.ttcn, line 1301 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_ps_bidir was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__ranap__mo__disconnect(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1305, TTCN_Location::LOCATION_FUNCTION, "f_tc_ranap_mo_disconnect");
current_location.update_lineno(1307);
/* HNBGW_Tests.ttcn, line 1307 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars)), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1309);
/* HNBGW_Tests.ttcn, line 1309 */
ConnHdlr::ConnHdlr_component_g__pars.rab__rel__cause() = RANAP__Templates::ts__RanapCause__radio__conn__release.valueof();
current_location.update_lineno(1312);
/* HNBGW_Tests.ttcn, line 1312 */
ConnHdlr::f__iuh2iu(RANAP__Templates::ts__RANAP__IuReleaseRequest(RANAP__IEs::Cause_template(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).rab__rel__cause()), RANAP__Templates::ts__RANAP__IuReleaseRequest_exts_defval), ConnHdlr::f__iuh2iu_exp__rx_defval);
current_location.update_lineno(1314);
/* HNBGW_Tests.ttcn, line 1314 */
ConnHdlr::f__cn__iu__release__procedure(ConnHdlr::f__cn__iu__release__procedure_mgcp__teardown_defval, ConnHdlr::f__cn__iu__release__procedure_pfcp__teardown_defval);
}

void start_f__tc__ranap__mo__disconnect(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ranap_mo_disconnect(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_ranap_mo_disconnect", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__ranap__cs__mo__disconnect(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1316, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_cs_mo_disconnect");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_cs_mo_disconnect", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1317);
/* HNBGW_Tests.ttcn, line 1317 */
COMPONENT vc__conn;
current_location.update_lineno(1318);
/* HNBGW_Tests.ttcn, line 1318 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1319);
/* HNBGW_Tests.ttcn, line 1319 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1321);
/* HNBGW_Tests.ttcn, line 1321 */
vc__conn = f__start__handler__with__pars(&f__tc__ranap__mo__disconnect, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(5, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1322);
/* HNBGW_Tests.ttcn, line 1322 */
{
tmp_163:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_163;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_163;
}
current_location.update_lineno(1322);
/* HNBGW_Tests.ttcn, line 1322 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1322.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1324);
/* HNBGW_Tests.ttcn, line 1324 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_cs_mo_disconnect was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ranap__ps__mo__disconnect(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1326, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_ps_mo_disconnect");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_ps_mo_disconnect", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1327);
/* HNBGW_Tests.ttcn, line 1327 */
COMPONENT vc__conn;
current_location.update_lineno(1328);
/* HNBGW_Tests.ttcn, line 1328 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1329);
/* HNBGW_Tests.ttcn, line 1329 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1331);
/* HNBGW_Tests.ttcn, line 1331 */
vc__conn = f__start__handler__with__pars(&f__tc__ranap__mo__disconnect, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(6, TRUE, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1332);
/* HNBGW_Tests.ttcn, line 1332 */
{
tmp_166:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_166;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_166;
}
current_location.update_lineno(1332);
/* HNBGW_Tests.ttcn, line 1332 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1332.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1334);
/* HNBGW_Tests.ttcn, line 1334 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_ps_mo_disconnect was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__ranap__creq__cref__ConnHdlr(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1338, TTCN_Location::LOCATION_FUNCTION, "f_tc_ranap_creq_cref_ConnHdlr");
current_location.update_lineno(1340);
/* HNBGW_Tests.ttcn, line 1340 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars)), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1343);
/* HNBGW_Tests.ttcn, line 1343 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(RAN__Emulation::ts__MSC__CONN__PRIM__DISC__REQ(INTEGER_template(SCCP__Templates::sccp__par__reason__end__user__failure)), FALSE, NULL);
current_location.update_lineno(1345);
/* HNBGW_Tests.ttcn, line 1345 */
{
tmp_167:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = RUA__Emulation::RUA__ConnHdlr_component_RUA.receive(RUA__Emulation::RUA__Disc__Ind_template(ANY_VALUE), NULL, any_compref, NULL, NULL, NULL);
if (alt_flag == ALT_YES) break;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_167;
}
current_location.update_lineno(1345);
/* HNBGW_Tests.ttcn, line 1345 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone receive statement failed in file HNBGW_Tests.ttcn, line 1345.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
}

void start_f__tc__ranap__creq__cref__ConnHdlr(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ranap_creq_cref_ConnHdlr(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_ranap_creq_cref_ConnHdlr", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__tc__ranap__creq__cref(const INTEGER& imsi__suffix, const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1347, TTCN_Location::LOCATION_FUNCTION, "f_tc_ranap_creq_cref");
current_location.update_lineno(1348);
/* HNBGW_Tests.ttcn, line 1348 */
COMPONENT vc__conn;
current_location.update_lineno(1349);
/* HNBGW_Tests.ttcn, line 1349 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1352);
/* HNBGW_Tests.ttcn, line 1352 */
test__CT_component_g__ran__ops.ranap__connect__ind__auto__res() = FALSE;
current_location.update_lineno(1353);
/* HNBGW_Tests.ttcn, line 1353 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1355);
/* HNBGW_Tests.ttcn, line 1355 */
vc__conn = f__start__handler__with__pars(&f__tc__ranap__creq__cref__ConnHdlr, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(imsi__suffix, ps__domain, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1356);
/* HNBGW_Tests.ttcn, line 1356 */
{
tmp_171:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_171;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_171;
}
current_location.update_lineno(1356);
/* HNBGW_Tests.ttcn, line 1356 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1356.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1358);
/* HNBGW_Tests.ttcn, line 1358 */
f__shutdown__helper();
}

void start_f__tc__ranap__creq__cref(const COMPONENT& component_reference, const INTEGER& imsi__suffix, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ranap_creq_cref(");
imsi__suffix.log();
TTCN_Logger::log_event_str(", ");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_ranap_creq_cref", text_buf);
imsi__suffix.encode_text(text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__ranap__cs__creq__cref(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1360, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_cs_creq_cref");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_cs_creq_cref", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1361);
/* HNBGW_Tests.ttcn, line 1361 */
f__tc__ranap__creq__cref(7, FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_cs_creq_cref was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ranap__ps__creq__cref(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1363, TTCN_Location::LOCATION_TESTCASE, "TC_ranap_ps_creq_cref");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ranap_ps_creq_cref", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1364);
/* HNBGW_Tests.ttcn, line 1364 */
f__tc__ranap__creq__cref(8, TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ranap_ps_creq_cref was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__rua__disconnect__during__sccp__cr__cc(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1369, TTCN_Location::LOCATION_FUNCTION, "f_tc_rua_disconnect_during_sccp_cr_cc");
current_location.update_lineno(1371);
/* HNBGW_Tests.ttcn, line 1371 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars)), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1374);
/* HNBGW_Tests.ttcn, line 1374 */
{
RUA__Emulation::RUA__Disc__Req_template tmp_172;
tmp_172.cause().misc() = RUA__IEs::CauseMisc::unspecified;
tmp_172.ranap() = OMIT_VALUE;
RUA__Emulation::RUA__ConnHdlr_component_RUA.send(tmp_172, FALSE, NULL);
}
current_location.update_lineno(1377);
/* HNBGW_Tests.ttcn, line 1377 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1380);
/* HNBGW_Tests.ttcn, line 1380 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(RAN__Emulation::ts__MSC__CONN__PRIM__CONNECT__RES, FALSE, NULL);
current_location.update_lineno(1383);
/* HNBGW_Tests.ttcn, line 1383 */
{
tmp_173:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.receive(RAN__Emulation::tr__MSC__CONN__PRIM__DISC__IND, NULL, any_compref, NULL, NULL, NULL);
if (alt_flag == ALT_YES) break;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_173;
}
current_location.update_lineno(1383);
/* HNBGW_Tests.ttcn, line 1383 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone receive statement failed in file HNBGW_Tests.ttcn, line 1383.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1385);
/* HNBGW_Tests.ttcn, line 1385 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__tc__rua__disconnect__during__sccp__cr__cc(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rua_disconnect_during_sccp_cr_cc(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_rua_disconnect_during_sccp_cr_cc", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__TC__rua__disconnect__during__sccp__cr__cc(const BOOLEAN& is__ps)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1387, TTCN_Location::LOCATION_FUNCTION, "f_TC_rua_disconnect_during_sccp_cr_cc");
current_location.update_lineno(1388);
/* HNBGW_Tests.ttcn, line 1388 */
COMPONENT vc__conn;
current_location.update_lineno(1389);
/* HNBGW_Tests.ttcn, line 1389 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1392);
/* HNBGW_Tests.ttcn, line 1392 */
test__CT_component_g__ran__ops.ranap__connect__ind__auto__res() = FALSE;
current_location.update_lineno(1393);
/* HNBGW_Tests.ttcn, line 1393 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1395);
/* HNBGW_Tests.ttcn, line 1395 */
vc__conn = f__start__handler__with__pars(&f__tc__rua__disconnect__during__sccp__cr__cc, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(6, is__ps, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1396);
/* HNBGW_Tests.ttcn, line 1396 */
{
tmp_177:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_177;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_177;
}
current_location.update_lineno(1396);
/* HNBGW_Tests.ttcn, line 1396 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1396.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1398);
/* HNBGW_Tests.ttcn, line 1398 */
f__shutdown__helper();
}

void start_f__TC__rua__disconnect__during__sccp__cr__cc(const COMPONENT& component_reference, const BOOLEAN& is__ps)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_rua_disconnect_during_sccp_cr_cc(");
is__ps.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_rua_disconnect_during_sccp_cr_cc", text_buf);
is__ps.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__cs__rua__disconnect__during__sccp__cr__cc(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1400, TTCN_Location::LOCATION_TESTCASE, "TC_cs_rua_disconnect_during_sccp_cr_cc");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_cs_rua_disconnect_during_sccp_cr_cc", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1401);
/* HNBGW_Tests.ttcn, line 1401 */
f__TC__rua__disconnect__during__sccp__cr__cc(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_cs_rua_disconnect_during_sccp_cr_cc was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ps__rua__disconnect__during__sccp__cr__cc(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1403, TTCN_Location::LOCATION_TESTCASE, "TC_ps_rua_disconnect_during_sccp_cr_cc");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ps_rua_disconnect_during_sccp_cr_cc", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1404);
/* HNBGW_Tests.ttcn, line 1404 */
f__TC__rua__disconnect__during__sccp__cr__cc(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ps_rua_disconnect_during_sccp_cr_cc was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__cs__iu__release__req__rua__disconnect(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1411, TTCN_Location::LOCATION_FUNCTION, "f_tc_cs_iu_release_req_rua_disconnect");
current_location.update_lineno(1412);
/* HNBGW_Tests.ttcn, line 1412 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1413);
/* HNBGW_Tests.ttcn, line 1413 */
TIMER T("T", 5.0);
current_location.update_lineno(1415);
/* HNBGW_Tests.ttcn, line 1415 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1416);
/* HNBGW_Tests.ttcn, line 1416 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1418);
/* HNBGW_Tests.ttcn, line 1418 */
ConnHdlr::f__create__rab__cs();
current_location.update_lineno(1420);
/* HNBGW_Tests.ttcn, line 1420 */
RUA__Emulation::RUA__ConnHdlr_component_RUA.send(RANAP__Templates::ts__RANAP__IuReleaseRequest(RANAP__Templates::ts__RanapCause__radio__rab__preempted, RANAP__Templates::ts__RANAP__IuReleaseRequest_exts_defval), FALSE, NULL);
current_location.update_lineno(1421);
/* HNBGW_Tests.ttcn, line 1421 */
{
tmp_179:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.receive(RANAP__Templates::tr__RANAP__IuReleaseRequest(RANAP__Templates::ts__RanapCause__radio__rab__preempted, RANAP__Templates::tr__RANAP__IuReleaseRequest_exts_defval), NULL, any_compref, NULL, NULL, NULL);
if (alt_flag == ALT_YES) break;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_179;
}
current_location.update_lineno(1421);
/* HNBGW_Tests.ttcn, line 1421 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone receive statement failed in file HNBGW_Tests.ttcn, line 1421.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1423);
/* HNBGW_Tests.ttcn, line 1423 */
{
RUA__Emulation::RUA__Disc__Req_template tmp_180;
tmp_180.cause().misc() = RUA__IEs::CauseMisc::unspecified;
tmp_180.ranap() = OMIT_VALUE;
RUA__Emulation::RUA__ConnHdlr_component_RUA.send(tmp_180, FALSE, NULL);
}
current_location.update_lineno(1426);
/* HNBGW_Tests.ttcn, line 1426 */
T.start();
current_location.update_lineno(1427);
/* HNBGW_Tests.ttcn, line 1427 */
{
tmp_181:
alt_status tmp_181_alt_flag_0 = ALT_MAYBE;
alt_status tmp_181_alt_flag_1 = ALT_MAYBE;
alt_status tmp_181_default_flag = ALT_MAYBE;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (tmp_181_alt_flag_0 == ALT_MAYBE) {
current_location.update_lineno(1428);
/* HNBGW_Tests.ttcn, line 1428 */
tmp_181_alt_flag_0 = ConnHdlr::as__mgcp__dlcx_instance(first_run);
if (tmp_181_alt_flag_0 == ALT_REPEAT) goto tmp_181;
if (tmp_181_alt_flag_0 == ALT_BREAK) break;
if (tmp_181_alt_flag_0 == ALT_YES) break;
}
if (tmp_181_alt_flag_1 == ALT_MAYBE) {
current_location.update_lineno(1429);
/* HNBGW_Tests.ttcn, line 1429 */
tmp_181_alt_flag_1 = T.timeout(NULL);
if (tmp_181_alt_flag_1 == ALT_YES) {
current_location.update_lineno(1430);
/* HNBGW_Tests.ttcn, line 1430 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("Timeout waiting for DLCX"),TTCN_Logger::end_event_log2str()));
break;
}
}
if (tmp_181_default_flag == ALT_MAYBE) {
tmp_181_default_flag = TTCN_Default::try_altsteps(first_run);
if (tmp_181_default_flag == ALT_YES || tmp_181_default_flag == ALT_BREAK) break;
else if (tmp_181_default_flag == ALT_REPEAT) goto tmp_181;
}
current_location.update_lineno(1427);
/* HNBGW_Tests.ttcn, line 1427 */
if (tmp_181_alt_flag_0 == ALT_NO && tmp_181_alt_flag_1 == ALT_NO && tmp_181_default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in the alt statement in file HNBGW_Tests.ttcn between lines 1427 and 1432.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1433);
/* HNBGW_Tests.ttcn, line 1433 */
T.stop();
current_location.update_lineno(1442);
/* HNBGW_Tests.ttcn, line 1442 */
{
tmp_182:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.receive(RAN__Emulation::tr__MSC__CONN__PRIM__DISC__IND, NULL, any_compref, NULL, NULL, NULL);
if (alt_flag == ALT_YES) break;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_182;
}
current_location.update_lineno(1442);
/* HNBGW_Tests.ttcn, line 1442 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone receive statement failed in file HNBGW_Tests.ttcn, line 1442.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1444);
/* HNBGW_Tests.ttcn, line 1444 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__tc__cs__iu__release__req__rua__disconnect(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_cs_iu_release_req_rua_disconnect(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_cs_iu_release_req_rua_disconnect", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__cs__iu__release__req__rua__disconnect(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1446, TTCN_Location::LOCATION_TESTCASE, "TC_cs_iu_release_req_rua_disconnect");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_cs_iu_release_req_rua_disconnect", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1447);
/* HNBGW_Tests.ttcn, line 1447 */
COMPONENT vc__conn;
current_location.update_lineno(1448);
/* HNBGW_Tests.ttcn, line 1448 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1449);
/* HNBGW_Tests.ttcn, line 1449 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1451);
/* HNBGW_Tests.ttcn, line 1451 */
vc__conn = f__start__handler__with__pars(&f__tc__cs__iu__release__req__rua__disconnect, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(9, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1452);
/* HNBGW_Tests.ttcn, line 1452 */
{
tmp_185:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_185;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_185;
}
current_location.update_lineno(1452);
/* HNBGW_Tests.ttcn, line 1452 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1452.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1454);
/* HNBGW_Tests.ttcn, line 1454 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_cs_iu_release_req_rua_disconnect was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__ps__iu__release__req__rua__disconnect(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1458, TTCN_Location::LOCATION_FUNCTION, "f_tc_ps_iu_release_req_rua_disconnect");
current_location.update_lineno(1459);
/* HNBGW_Tests.ttcn, line 1459 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1461);
/* HNBGW_Tests.ttcn, line 1461 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1462);
/* HNBGW_Tests.ttcn, line 1462 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1464);
/* HNBGW_Tests.ttcn, line 1464 */
ConnHdlr::f__create__rab__ps();
current_location.update_lineno(1466);
/* HNBGW_Tests.ttcn, line 1466 */
RUA__Emulation::RUA__ConnHdlr_component_RUA.send(RANAP__Templates::ts__RANAP__IuReleaseRequest(RANAP__Templates::ts__RanapCause__radio__rab__preempted, RANAP__Templates::ts__RANAP__IuReleaseRequest_exts_defval), FALSE, NULL);
current_location.update_lineno(1467);
/* HNBGW_Tests.ttcn, line 1467 */
{
tmp_187:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.receive(RANAP__Templates::tr__RANAP__IuReleaseRequest(RANAP__Templates::ts__RanapCause__radio__rab__preempted, RANAP__Templates::tr__RANAP__IuReleaseRequest_exts_defval), NULL, any_compref, NULL, NULL, NULL);
if (alt_flag == ALT_YES) break;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_187;
}
current_location.update_lineno(1467);
/* HNBGW_Tests.ttcn, line 1467 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone receive statement failed in file HNBGW_Tests.ttcn, line 1467.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1469);
/* HNBGW_Tests.ttcn, line 1469 */
{
RUA__Emulation::RUA__Disc__Req_template tmp_188;
tmp_188.cause().misc() = RUA__IEs::CauseMisc::unspecified;
tmp_188.ranap() = OMIT_VALUE;
RUA__Emulation::RUA__ConnHdlr_component_RUA.send(tmp_188, FALSE, NULL);
}
current_location.update_lineno(1472);
/* HNBGW_Tests.ttcn, line 1472 */
if (const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).pfcp__pars().pfcp__enabled()) {
current_location.update_lineno(1473);
/* HNBGW_Tests.ttcn, line 1473 */
ConnHdlr::as__pfcp__handle__del__req(FALSE);
}
current_location.update_lineno(1483);
/* HNBGW_Tests.ttcn, line 1483 */
{
tmp_189:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.receive(RAN__Emulation::tr__MSC__CONN__PRIM__DISC__IND, NULL, any_compref, NULL, NULL, NULL);
if (alt_flag == ALT_YES) break;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_189;
}
current_location.update_lineno(1483);
/* HNBGW_Tests.ttcn, line 1483 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone receive statement failed in file HNBGW_Tests.ttcn, line 1483.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1485);
/* HNBGW_Tests.ttcn, line 1485 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__tc__ps__iu__release__req__rua__disconnect(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ps_iu_release_req_rua_disconnect(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_ps_iu_release_req_rua_disconnect", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__ps__iu__release__req__rua__disconnect(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1487, TTCN_Location::LOCATION_TESTCASE, "TC_ps_iu_release_req_rua_disconnect");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ps_iu_release_req_rua_disconnect", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1488);
/* HNBGW_Tests.ttcn, line 1488 */
COMPONENT vc__conn;
current_location.update_lineno(1489);
/* HNBGW_Tests.ttcn, line 1489 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1490);
/* HNBGW_Tests.ttcn, line 1490 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1491);
/* HNBGW_Tests.ttcn, line 1491 */
vc__conn = f__start__handler__with__pars(&f__tc__ps__iu__release__req__rua__disconnect, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(9, TRUE, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1492);
/* HNBGW_Tests.ttcn, line 1492 */
{
tmp_192:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_192;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_192;
}
current_location.update_lineno(1492);
/* HNBGW_Tests.ttcn, line 1492 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1492.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1494);
/* HNBGW_Tests.ttcn, line 1494 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ps_iu_release_req_rua_disconnect was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__rua__dt__during__sccp__wait__cc(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1500, TTCN_Location::LOCATION_FUNCTION, "f_tc_rua_dt_during_sccp_wait_cc");
current_location.update_lineno(1502);
/* HNBGW_Tests.ttcn, line 1502 */
RANAP__PDU__Descriptions::RANAP__PDU tx__ranap__pdu(ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars));
current_location.update_lineno(1503);
/* HNBGW_Tests.ttcn, line 1503 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars)), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1509);
/* HNBGW_Tests.ttcn, line 1509 */
tx__ranap__pdu = RANAP__Templates::ts__RANAP__IuReleaseRequest(RANAP__Templates::ts__RanapCause__nas__normal, RANAP__Templates::ts__RANAP__IuReleaseRequest_exts_defval).valueof();
current_location.update_lineno(1510);
/* HNBGW_Tests.ttcn, line 1510 */
RUA__Emulation::RUA__ConnHdlr_component_RUA.send(tx__ranap__pdu, FALSE, NULL);
current_location.update_lineno(1513);
/* HNBGW_Tests.ttcn, line 1513 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1516);
/* HNBGW_Tests.ttcn, line 1516 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(RAN__Emulation::ts__MSC__CONN__PRIM__CONNECT__RES, FALSE, NULL);
current_location.update_lineno(1519);
/* HNBGW_Tests.ttcn, line 1519 */
ConnHdlr::f__bssap__expect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx__ranap__pdu));
current_location.update_lineno(1523);
/* HNBGW_Tests.ttcn, line 1523 */
tx__ranap__pdu = RANAP__Templates::ts__RANAP__DirectTransfer(OCTETSTRING_template(Osmocom__Types::f__rnd__octstring(10)), RANAP__Templates::ts__RANAP__DirectTransfer_sapi_defval, RANAP__Templates::ts__RANAP__DirectTransfer_ies_defval, RANAP__Templates::ts__RANAP__DirectTransfer_exts_defval).valueof();
current_location.update_lineno(1524);
/* HNBGW_Tests.ttcn, line 1524 */
ConnHdlr::f__iu2iuh(RANAP__PDU__Descriptions::RANAP__PDU_template(tx__ranap__pdu), ConnHdlr::f__iu2iuh_exp__rx_defval);
current_location.update_lineno(1526);
/* HNBGW_Tests.ttcn, line 1526 */
ConnHdlr::f__cn__iu__release__procedure(ConnHdlr::f__cn__iu__release__procedure_mgcp__teardown_defval, ConnHdlr::f__cn__iu__release__procedure_pfcp__teardown_defval);
}

void start_f__tc__rua__dt__during__sccp__wait__cc(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rua_dt_during_sccp_wait_cc(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_rua_dt_during_sccp_wait_cc", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__TC__rua__dt__during__sccp__wait__cc(const BOOLEAN& is__ps)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1528, TTCN_Location::LOCATION_FUNCTION, "f_TC_rua_dt_during_sccp_wait_cc");
current_location.update_lineno(1529);
/* HNBGW_Tests.ttcn, line 1529 */
COMPONENT vc__conn;
current_location.update_lineno(1530);
/* HNBGW_Tests.ttcn, line 1530 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1533);
/* HNBGW_Tests.ttcn, line 1533 */
test__CT_component_g__ran__ops.ranap__connect__ind__auto__res() = FALSE;
current_location.update_lineno(1534);
/* HNBGW_Tests.ttcn, line 1534 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1536);
/* HNBGW_Tests.ttcn, line 1536 */
vc__conn = f__start__handler__with__pars(&f__tc__rua__dt__during__sccp__wait__cc, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(6, is__ps, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1537);
/* HNBGW_Tests.ttcn, line 1537 */
{
tmp_198:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_198;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_198;
}
current_location.update_lineno(1537);
/* HNBGW_Tests.ttcn, line 1537 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1537.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1539);
/* HNBGW_Tests.ttcn, line 1539 */
f__shutdown__helper();
}

void start_f__TC__rua__dt__during__sccp__wait__cc(const COMPONENT& component_reference, const BOOLEAN& is__ps)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_rua_dt_during_sccp_wait_cc(");
is__ps.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_rua_dt_during_sccp_wait_cc", text_buf);
is__ps.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__cs__rua__dt__during__sccp__wait__cc(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1541, TTCN_Location::LOCATION_TESTCASE, "TC_cs_rua_dt_during_sccp_wait_cc");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_cs_rua_dt_during_sccp_wait_cc", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1542);
/* HNBGW_Tests.ttcn, line 1542 */
f__TC__rua__dt__during__sccp__wait__cc(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_cs_rua_dt_during_sccp_wait_cc was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ps__rua__dt__during__sccp__wait__cc(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1543, TTCN_Location::LOCATION_TESTCASE, "TC_ps_rua_dt_during_sccp_wait_cc");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ps_rua_dt_during_sccp_wait_cc", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1544);
/* HNBGW_Tests.ttcn, line 1544 */
f__TC__rua__dt__during__sccp__wait__cc(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ps_rua_dt_during_sccp_wait_cc was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__ps__rab__assignment(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1547, TTCN_Location::LOCATION_FUNCTION, "f_tc_ps_rab_assignment");
current_location.update_lineno(1548);
/* HNBGW_Tests.ttcn, line 1548 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1550);
/* HNBGW_Tests.ttcn, line 1550 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1551);
/* HNBGW_Tests.ttcn, line 1551 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1553);
/* HNBGW_Tests.ttcn, line 1553 */
ConnHdlr::f__create__rab__ps();
current_location.update_lineno(1554);
/* HNBGW_Tests.ttcn, line 1554 */
Osmocom__Types::f__sleep(2.0);
current_location.update_lineno(1556);
/* HNBGW_Tests.ttcn, line 1556 */
ConnHdlr::f__cn__iu__release__procedure(ConnHdlr::f__cn__iu__release__procedure_mgcp__teardown_defval, BOOLEAN(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).pfcp__pars().pfcp__enabled()));
}

void start_f__tc__ps__rab__assignment(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ps_rab_assignment(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_ps_rab_assignment", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__ps__rab__assignment(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1558, TTCN_Location::LOCATION_TESTCASE, "TC_ps_rab_assignment");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ps_rab_assignment", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1559);
/* HNBGW_Tests.ttcn, line 1559 */
COMPONENT vc__conn;
current_location.update_lineno(1560);
/* HNBGW_Tests.ttcn, line 1560 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1561);
/* HNBGW_Tests.ttcn, line 1561 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1562);
/* HNBGW_Tests.ttcn, line 1562 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1564);
/* HNBGW_Tests.ttcn, line 1564 */
vc__conn = f__start__handler__with__pars(&f__tc__ps__rab__assignment, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(7, TRUE, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1565);
/* HNBGW_Tests.ttcn, line 1565 */
{
tmp_202:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_202;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_202;
}
current_location.update_lineno(1565);
/* HNBGW_Tests.ttcn, line 1565 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1565.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1567);
/* HNBGW_Tests.ttcn, line 1567 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ps_rab_assignment was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ps__rab__assignment__concurrent(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1573, TTCN_Location::LOCATION_TESTCASE, "TC_ps_rab_assignment_concurrent");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ps_rab_assignment_concurrent", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1574);
/* HNBGW_Tests.ttcn, line 1574 */
ConnHdlr::ConnHdlrList vc__conn__list(NULL_VALUE);
current_location.update_lineno(1575);
/* HNBGW_Tests.ttcn, line 1575 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1576);
/* HNBGW_Tests.ttcn, line 1576 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1577);
/* HNBGW_Tests.ttcn, line 1577 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1578);
/* HNBGW_Tests.ttcn, line 1578 */
INTEGER num__conns(16);
{
current_location.update_lineno(1580);
/* HNBGW_Tests.ttcn, line 1580 */
INTEGER i(0);
current_location.update_lineno(1580);
/* HNBGW_Tests.ttcn, line 1580 */
for ( ; ; ) {
current_location.update_lineno(1580);
/* HNBGW_Tests.ttcn, line 1580 */
if (!(i < 16)) break;
current_location.update_lineno(1581);
/* HNBGW_Tests.ttcn, line 1581 */
COMPONENT vc__conn;
current_location.update_lineno(1582);
/* HNBGW_Tests.ttcn, line 1582 */
ConnHdlr::TestHdlrParams pars(f__TestHdlrParams(i, TRUE, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval));
current_location.update_lineno(1583);
/* HNBGW_Tests.ttcn, line 1583 */
vc__conn = f__start__handler__with__pars(&f__tc__ps__rab__assignment, ConnHdlr::TestHdlrParams_template(pars));
current_location.update_lineno(1584);
/* HNBGW_Tests.ttcn, line 1584 */
{
ConnHdlr::ConnHdlrList tmp_205;
{
ConnHdlr::ConnHdlrList tmp_206;
tmp_206.set_size(1);
tmp_206[0] = vc__conn;
tmp_205 = (vc__conn__list + tmp_206);
}
vc__conn__list = tmp_205;
}
current_location.update_lineno(1580);
/* HNBGW_Tests.ttcn, line 1580 */
{
INTEGER tmp_207;
++i;
}
}
}
current_location.update_lineno(1587);
/* HNBGW_Tests.ttcn, line 1587 */
f__ConnHdlrList__all__done(vc__conn__list);
current_location.update_lineno(1588);
/* HNBGW_Tests.ttcn, line 1588 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ps_rab_assignment_concurrent was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__ps__tc__rab__release(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1594, TTCN_Location::LOCATION_FUNCTION, "f_ps_tc_rab_release");
current_location.update_lineno(1595);
/* HNBGW_Tests.ttcn, line 1595 */
CHARSTRING hnb0__ctr__prefix(f__hnb__ctr__prefix(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()));
current_location.update_lineno(1596);
/* HNBGW_Tests.ttcn, line 1596 */
MGCP__Types::MgcpCommand mgcp__cmd;
current_location.update_lineno(1597);
/* HNBGW_Tests.ttcn, line 1597 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(1598);
/* HNBGW_Tests.ttcn, line 1598 */
TIMER T("T", 1.5e1);
current_location.update_lineno(1600);
/* HNBGW_Tests.ttcn, line 1600 */
StatsD__Checker::f__statsd__reset();
current_location.update_lineno(1602);
/* HNBGW_Tests.ttcn, line 1602 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(1603);
/* HNBGW_Tests.ttcn, line 1603 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(1605);
/* HNBGW_Tests.ttcn, line 1605 */
ConnHdlr::f__create__rab__ps();
current_location.update_lineno(1607);
/* HNBGW_Tests.ttcn, line 1607 */
CHARSTRING ctr__name;
current_location.update_lineno(1608);
/* HNBGW_Tests.ttcn, line 1608 */
if ((const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).rab__rel__cause() == RANAP__Templates::ts__RanapCause__nas__normal.valueof())) {
current_location.update_lineno(1609);
/* HNBGW_Tests.ttcn, line 1609 */
ctr__name = cs_60;
}
else {
current_location.update_lineno(1611);
/* HNBGW_Tests.ttcn, line 1611 */
ctr__name = cs_61;
}
current_location.update_lineno(1615);
/* HNBGW_Tests.ttcn, line 1615 */
StatsD__Checker::StatsDExpects expect;
expect.set_size(1);
{
StatsD__Checker::StatsDExpect& tmp_211 = expect[0];
tmp_211.name() = (hnb0__ctr__prefix + ctr__name);
tmp_211.mtype() = cs_54;
tmp_211.min() = 0;
tmp_211.max() = 0;
}
current_location.update_lineno(1618);
/* HNBGW_Tests.ttcn, line 1618 */
StatsD__Checker::f__statsd__expect(expect, StatsD__Checker::f__statsd__expect_wait__converge_defval);
current_location.update_lineno(1621);
/* HNBGW_Tests.ttcn, line 1621 */
tx = RANAP__Templates::ts__RANAP__RabAssReq(RANAP__Templates::ts__RANAP__RabAssReq_rab__sml_defval, RANAP__Templates::ts__RAB__RL(RANAP__Templates::t__RAB__id(23), RANAP__IEs::Cause_template(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).rab__rel__cause())), RANAP__Templates::ts__RANAP__RabAssReq_exts_defval).valueof();
current_location.update_lineno(1622);
/* HNBGW_Tests.ttcn, line 1622 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(tx, FALSE, NULL);
current_location.update_lineno(1623);
/* HNBGW_Tests.ttcn, line 1623 */
ConnHdlr::f__rua__expect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx));
current_location.update_lineno(1625);
/* HNBGW_Tests.ttcn, line 1625 */
tx = RANAP__Templates::ts__RANAP__RabAssResp(RANAP__Templates::ts__RANAP__RabAssResp_rab__sml_defval, RANAP__Templates::ts__RAB__RLD(RANAP__Templates::t__RAB__id(23)), RANAP__Templates::ts__RANAP__RabAssResp_rab__fl_defval, RANAP__Templates::ts__RANAP__RabAssResp_exts_defval).valueof();
current_location.update_lineno(1626);
/* HNBGW_Tests.ttcn, line 1626 */
RUA__Emulation::RUA__ConnHdlr_component_RUA.send(tx, FALSE, NULL);
current_location.update_lineno(1628);
/* HNBGW_Tests.ttcn, line 1628 */
if (const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).pfcp__pars().pfcp__enabled()) {
current_location.update_lineno(1629);
/* HNBGW_Tests.ttcn, line 1629 */
T.start();
current_location.update_lineno(1630);
/* HNBGW_Tests.ttcn, line 1630 */
{
tmp_214:
alt_status tmp_214_alt_flag_0 = ALT_MAYBE;
alt_status tmp_214_alt_flag_1 = ALT_MAYBE;
alt_status tmp_214_default_flag = ALT_MAYBE;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (tmp_214_alt_flag_0 == ALT_MAYBE) {
current_location.update_lineno(1631);
/* HNBGW_Tests.ttcn, line 1631 */
tmp_214_alt_flag_0 = ConnHdlr::as__pfcp__handle__del__req_instance(first_run);
if (tmp_214_alt_flag_0 == ALT_REPEAT) goto tmp_214;
if (tmp_214_alt_flag_0 == ALT_BREAK) break;
if (tmp_214_alt_flag_0 == ALT_YES) break;
}
if (tmp_214_alt_flag_1 == ALT_MAYBE) {
current_location.update_lineno(1632);
/* HNBGW_Tests.ttcn, line 1632 */
tmp_214_alt_flag_1 = T.timeout(NULL);
if (tmp_214_alt_flag_1 == ALT_YES) {
current_location.update_lineno(1633);
/* HNBGW_Tests.ttcn, line 1633 */
Misc__Helpers::f__shutdown(cs_13, 1633, FAIL, cs_62);
break;
}
}
if (tmp_214_default_flag == ALT_MAYBE) {
tmp_214_default_flag = TTCN_Default::try_altsteps(first_run);
if (tmp_214_default_flag == ALT_YES || tmp_214_default_flag == ALT_BREAK) break;
else if (tmp_214_default_flag == ALT_REPEAT) goto tmp_214;
}
current_location.update_lineno(1630);
/* HNBGW_Tests.ttcn, line 1630 */
if (tmp_214_alt_flag_0 == ALT_NO && tmp_214_alt_flag_1 == ALT_NO && tmp_214_default_flag == ALT_NO) TTCN_error("None of the branches can be chosen in the alt statement in file HNBGW_Tests.ttcn between lines 1630 and 1636.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1637);
/* HNBGW_Tests.ttcn, line 1637 */
T.stop();
}
current_location.update_lineno(1640);
/* HNBGW_Tests.ttcn, line 1640 */
ConnHdlr::f__bssap__expect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx));
current_location.update_lineno(1642);
/* HNBGW_Tests.ttcn, line 1642 */
expect.set_size(1);
{
StatsD__Checker::StatsDExpect& tmp_216 = expect[0];
tmp_216.name() = (hnb0__ctr__prefix + ctr__name);
tmp_216.mtype() = cs_54;
tmp_216.min() = 1;
tmp_216.max() = 1;
}
current_location.update_lineno(1645);
/* HNBGW_Tests.ttcn, line 1645 */
StatsD__Checker::f__statsd__expect(expect, StatsD__Checker::f__statsd__expect_wait__converge_defval);
}

void start_f__ps__tc__rab__release(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ps_tc_rab_release(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ps_tc_rab_release", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__ps__rab__release(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1647, TTCN_Location::LOCATION_TESTCASE, "TC_ps_rab_release");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ps_rab_release", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1648);
/* HNBGW_Tests.ttcn, line 1648 */
COMPONENT vc__conn;
current_location.update_lineno(1649);
/* HNBGW_Tests.ttcn, line 1649 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1650);
/* HNBGW_Tests.ttcn, line 1650 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1652);
/* HNBGW_Tests.ttcn, line 1652 */
vc__conn = f__start__handler__with__pars(&f__ps__tc__rab__release, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(5, TRUE, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(1653);
/* HNBGW_Tests.ttcn, line 1653 */
{
tmp_219:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_219;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_219;
}
current_location.update_lineno(1653);
/* HNBGW_Tests.ttcn, line 1653 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1653.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1655);
/* HNBGW_Tests.ttcn, line 1655 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ps_rab_release was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__ps__rab__release__abnormal(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1658, TTCN_Location::LOCATION_TESTCASE, "TC_ps_rab_release_abnormal");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_ps_rab_release_abnormal", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1659);
/* HNBGW_Tests.ttcn, line 1659 */
COMPONENT vc__conn;
current_location.update_lineno(1660);
/* HNBGW_Tests.ttcn, line 1660 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(1661);
/* HNBGW_Tests.ttcn, line 1661 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1663);
/* HNBGW_Tests.ttcn, line 1663 */
vc__conn = f__start__handler__with__pars(&f__ps__tc__rab__release, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(8, TRUE, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, RANAP__Templates::ts__RanapCause__radio__conn__lost)));
current_location.update_lineno(1665);
/* HNBGW_Tests.ttcn, line 1665 */
{
tmp_222:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_222;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_222;
}
current_location.update_lineno(1665);
/* HNBGW_Tests.ttcn, line 1665 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1665.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1667);
/* HNBGW_Tests.ttcn, line 1667 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_ps_rab_release_abnormal was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__ctrs__cn__init(const BOOLEAN& ps__domain, const INTEGER& cn__count, const Osmocom__CTRL__Functions::CounterNameVals& counternames)
{
INTEGER cn__count_shadow(cn__count);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1678, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_cn_init");
current_location.update_lineno(1680);
/* HNBGW_Tests.ttcn, line 1680 */
if (ps__domain) {
current_location.update_lineno(1681);
/* HNBGW_Tests.ttcn, line 1681 */
test__CT_component_g__ctr__cn__node__name = cs_18;
current_location.update_lineno(1682);
/* HNBGW_Tests.ttcn, line 1682 */
if ((cn__count_shadow == 0)) {
current_location.update_lineno(1683);
/* HNBGW_Tests.ttcn, line 1683 */
cn__count_shadow = 4;
}
}
else {
current_location.update_lineno(1686);
/* HNBGW_Tests.ttcn, line 1686 */
test__CT_component_g__ctr__cn__node__name = cs_19;
current_location.update_lineno(1687);
/* HNBGW_Tests.ttcn, line 1687 */
if ((cn__count_shadow == 0)) {
current_location.update_lineno(1688);
/* HNBGW_Tests.ttcn, line 1688 */
cn__count_shadow = 4;
}
}
current_location.update_lineno(1691);
/* HNBGW_Tests.ttcn, line 1691 */
test__CT_component_g__ctr__cn = Osmocom__CTRL__Functions::f__counter__name__vals__get__n(Osmocom__CTRL__Adapter::CTRL__Adapter__CT_component_IPA__CTRL, test__CT_component_g__ctr__cn__node__name, cn__count_shadow, counternames, Osmocom__CTRL__Functions::f__counter__name__vals__get__n_start__idx_defval);
current_location.update_lineno(1692);
/* HNBGW_Tests.ttcn, line 1692 */
try {
TTCN_Logger::begin_event(TTCN_USER);
((cs_68 + test__CT_component_g__ctr__cn__node__name) + cs_69).log();
test__CT_component_g__ctr__cn.log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
}

void start_f__ctrs__cn__init(const COMPONENT& component_reference, const BOOLEAN& ps__domain, const INTEGER& cn__count, const Osmocom__CTRL__Functions::CounterNameVals& counternames)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_cn_init(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
cn__count.log();
TTCN_Logger::log_event_str(", ");
counternames.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_cn_init", text_buf);
ps__domain.encode_text(text_buf);
cn__count.encode_text(text_buf);
counternames.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__ctrs__cn__verify()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1703, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_cn_verify");
current_location.update_lineno(1704);
/* HNBGW_Tests.ttcn, line 1704 */
try {
TTCN_Logger::begin_event(TTCN_USER);
TTCN_Logger::log_event_str("verifying");
test__CT_component_g__ctr__cn__node__name.log();
TTCN_Logger::log_event_str(" rate counters: ");
test__CT_component_g__ctr__cn.log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
current_location.update_lineno(1705);
/* HNBGW_Tests.ttcn, line 1705 */
Osmocom__CTRL__Functions::f__counter__name__vals__expect__n(Osmocom__CTRL__Adapter::CTRL__Adapter__CT_component_IPA__CTRL, test__CT_component_g__ctr__cn__node__name, test__CT_component_g__ctr__cn);
}

void start_f__ctrs__cn__verify(const COMPONENT& component_reference)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_cn_verify(");
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_cn_verify", text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__ctrs__cn__expect(const INTEGER& cn__nr, const CHARSTRING& countername, const INTEGER& val)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1715, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_cn_expect");
current_location.update_lineno(1716);
/* HNBGW_Tests.ttcn, line 1716 */
f__ctrs__cn__add(cn__nr, countername, val);
current_location.update_lineno(1717);
/* HNBGW_Tests.ttcn, line 1717 */
f__ctrs__cn__verify();
}

void start_f__ctrs__cn__expect(const COMPONENT& component_reference, const INTEGER& cn__nr, const CHARSTRING& countername, const INTEGER& val)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_cn_expect(");
cn__nr.log();
TTCN_Logger::log_event_str(", ");
countername.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_cn_expect", text_buf);
cn__nr.encode_text(text_buf);
countername.encode_text(text_buf);
val.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__ctrs__cn__add(const INTEGER& cn__nr, const CHARSTRING& countername, const INTEGER& val)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1720, TTCN_Location::LOCATION_FUNCTION, "f_ctrs_cn_add");
current_location.update_lineno(1721);
/* HNBGW_Tests.ttcn, line 1721 */
Osmocom__CTRL__Functions::f__counter__name__vals__list__add(test__CT_component_g__ctr__cn, cn__nr, countername, val);
}

void start_f__ctrs__cn__add(const COMPONENT& component_reference, const INTEGER& cn__nr, const CHARSTRING& countername, const INTEGER& val)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_cn_add(");
cn__nr.log();
TTCN_Logger::log_event_str(", ");
countername.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_ctrs_cn_add", text_buf);
cn__nr.encode_text(text_buf);
countername.encode_text(text_buf);
val.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__tc__cnpool__compl__l3(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1724, TTCN_Location::LOCATION_FUNCTION, "f_tc_cnpool_compl_l3");
current_location.update_lineno(1725);
/* HNBGW_Tests.ttcn, line 1725 */
ConnHdlr::f__perform__compl__l3(OCTETSTRING(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).nas__pdu()), ConnHdlr::f__perform__compl__l3_do__clear_defval, BOOLEAN(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).expect__compl__l3__success()));
}

void start_f__tc__cnpool__compl__l3(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_cnpool_compl_l3(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_cnpool_compl_l3", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__TC__cnpool__compl__l3(const BOOLEAN& ps__domain, const OCTETSTRING& nas__pdu, const INTEGER& cn__nr, const CHARSTRING_template& inc__countername, const BOOLEAN& expect__compl__l3__success)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1728, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_compl_l3");
current_location.update_lineno(1731);
/* HNBGW_Tests.ttcn, line 1731 */
COMPONENT vc__conn;
current_location.update_lineno(1732);
/* HNBGW_Tests.ttcn, line 1732 */
ConnHdlr::TestHdlrParams_template pars(f__TestHdlrParams(0, ps__domain, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, cn__nr, f__TestHdlrParams_rab__rel__cause_defval));
current_location.update_lineno(1733);
/* HNBGW_Tests.ttcn, line 1733 */
pars.nas__pdu() = nas__pdu;
current_location.update_lineno(1734);
/* HNBGW_Tests.ttcn, line 1734 */
pars.expect__compl__l3__success() = expect__compl__l3__success;
current_location.update_lineno(1735);
/* HNBGW_Tests.ttcn, line 1735 */
try {
TTCN_Logger::begin_event(TTCN_USER);
TTCN_Logger::log_event_str("XXX ");
pars.log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
current_location.update_lineno(1736);
/* HNBGW_Tests.ttcn, line 1736 */
vc__conn = f__start__handler__with__pars(&f__tc__cnpool__compl__l3, pars);
current_location.update_lineno(1737);
/* HNBGW_Tests.ttcn, line 1737 */
{
tmp_236:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_236;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_236;
}
current_location.update_lineno(1737);
/* HNBGW_Tests.ttcn, line 1737 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 1737.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(1739);
/* HNBGW_Tests.ttcn, line 1739 */
if ((!(inc__countername.get_istemplate_kind((const char*)cs_70)))) {
current_location.update_lineno(1740);
/* HNBGW_Tests.ttcn, line 1740 */
f__ctrs__cn__expect(cn__nr, inc__countername.valueof(), f__ctrs__cn__expect_val_defval);
}
}

void start_f__TC__cnpool__compl__l3(const COMPONENT& component_reference, const BOOLEAN& ps__domain, const OCTETSTRING& nas__pdu, const INTEGER& cn__nr, const CHARSTRING_template& inc__countername, const BOOLEAN& expect__compl__l3__success)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_compl_l3(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
nas__pdu.log();
TTCN_Logger::log_event_str(", ");
cn__nr.log();
TTCN_Logger::log_event_str(", ");
inc__countername.log();
TTCN_Logger::log_event_str(", ");
expect__compl__l3__success.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_compl_l3", text_buf);
ps__domain.encode_text(text_buf);
nas__pdu.encode_text(text_buf);
cn__nr.encode_text(text_buf);
inc__countername.encode_text(text_buf);
expect__compl__l3__success.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__TC__cnpool__compl__l3__list(const BOOLEAN& ps__domain, const ro__octetstring& compl3, const Osmocom__Types::ro__integer& cn__nrs, const CHARSTRING_template& inc__countername, const BOOLEAN& expect__compl__l3__success)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1744, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_compl_l3_list");
current_location.update_lineno(1747);
/* HNBGW_Tests.ttcn, line 1747 */
INTEGER n(compl3.lengthof());
current_location.update_lineno(1748);
/* HNBGW_Tests.ttcn, line 1748 */
if ((n < cn__nrs.lengthof())) {
current_location.update_lineno(1749);
/* HNBGW_Tests.ttcn, line 1749 */
n = cn__nrs.lengthof();
}
{
current_location.update_lineno(1751);
/* HNBGW_Tests.ttcn, line 1751 */
INTEGER i(0);
current_location.update_lineno(1751);
/* HNBGW_Tests.ttcn, line 1751 */
for ( ; ; ) {
current_location.update_lineno(1751);
/* HNBGW_Tests.ttcn, line 1751 */
if (!(i < n)) break;
current_location.update_lineno(1752);
/* HNBGW_Tests.ttcn, line 1752 */
INTEGER cn__nr(const_cast< const Osmocom__Types::ro__integer&>(cn__nrs)[mod(i, cn__nrs.lengthof())]);
current_location.update_lineno(1753);
/* HNBGW_Tests.ttcn, line 1753 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[mod(i, compl3.lengthof())], cn__nr, inc__countername, expect__compl__l3__success);
current_location.update_lineno(1751);
/* HNBGW_Tests.ttcn, line 1751 */
{
INTEGER tmp_238;
++i;
}
}
}
}

void start_f__TC__cnpool__compl__l3__list(const COMPONENT& component_reference, const BOOLEAN& ps__domain, const ro__octetstring& compl3, const Osmocom__Types::ro__integer& cn__nrs, const CHARSTRING_template& inc__countername, const BOOLEAN& expect__compl__l3__success)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_compl_l3_list(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
compl3.log();
TTCN_Logger::log_event_str(", ");
cn__nrs.log();
TTCN_Logger::log_event_str(", ");
inc__countername.log();
TTCN_Logger::log_event_str(", ");
expect__compl__l3__success.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_compl_l3_list", text_buf);
ps__domain.encode_text(text_buf);
compl3.encode_text(text_buf);
cn__nrs.encode_text(text_buf);
inc__countername.encode_text(text_buf);
expect__compl__l3__success.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

OCTETSTRING f__gen__one__compl__l3(const Compl3Type& compl3type, const MobileL3__CommonIE__Types::MobileIdentityLV_template& mi, const INTEGER& ps__nri)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1771, TTCN_Location::LOCATION_FUNCTION, "f_gen_one_compl_l3");
current_location.update_lineno(1776);
/* HNBGW_Tests.ttcn, line 1776 */
if ((compl3type == Compl3Type::LU)) {
current_location.update_lineno(1777);
/* HNBGW_Tests.ttcn, line 1777 */
return MobileL3__Types::enc__PDU__ML3__MS__NW(L3__Templates::ts__LU__REQ(L3__Templates::LU__Type__IMSI__Attach, MobileL3__CommonIE__Types::MobileIdentityLV_template(mi.valueof()), OCTETSTRING_template(os_0)).valueof());
}
current_location.update_lineno(1779);
/* HNBGW_Tests.ttcn, line 1779 */
if ((compl3type == Compl3Type::CMSERV)) {
current_location.update_lineno(1780);
/* HNBGW_Tests.ttcn, line 1780 */
return MobileL3__Types::enc__PDU__ML3__MS__NW(L3__Templates::ts__CM__SERV__REQ(L3__Templates::CmServiceType::CM__TYPE__MO__CALL, mi.valueof()).valueof());
}
current_location.update_lineno(1782);
/* HNBGW_Tests.ttcn, line 1782 */
if ((compl3type == Compl3Type::PAGRESP)) {
current_location.update_lineno(1783);
/* HNBGW_Tests.ttcn, line 1783 */
return MobileL3__Types::enc__PDU__ML3__MS__NW(L3__Templates::ts__PAG__RESP(MobileL3__CommonIE__Types::MobileIdentityLV_template(mi.valueof())).valueof());
}
current_location.update_lineno(1785);
/* HNBGW_Tests.ttcn, line 1785 */
if ((compl3type == Compl3Type::IMSIDETACH)) {
current_location.update_lineno(1786);
/* HNBGW_Tests.ttcn, line 1786 */
return MobileL3__Types::enc__PDU__ML3__MS__NW(L3__Templates::ts__ML3__MO__MM__IMSI__DET__Ind(mi.valueof(), L3__Templates::ts__ML3__MO__MM__IMSI__DET__Ind_cm1_defval).valueof());
}
current_location.update_lineno(1790);
/* HNBGW_Tests.ttcn, line 1790 */
MobileL3__GMM__SM__Types::NetworkResourceIdentifierContainerTLV_template nri(OMIT_VALUE);
current_location.update_lineno(1791);
/* HNBGW_Tests.ttcn, line 1791 */
if ((ps__nri >= 0)) {
current_location.update_lineno(1792);
/* HNBGW_Tests.ttcn, line 1792 */
nri = L3__Templates::ts__GMM__NRI(ps__nri).valueof();
}
current_location.update_lineno(1795);
/* HNBGW_Tests.ttcn, line 1795 */
if ((compl3type == Compl3Type::ATTACHREQ)) {
current_location.update_lineno(1796);
/* HNBGW_Tests.ttcn, line 1796 */
return MobileL3__Types::enc__PDU__L3__MS__SGSN(L3__Templates::ts__GMM__ATTACH__REQ(mi.valueof(), L3__Common::f__RAI(hs_1, hs_2, os_2, os_3), L3__Templates::ts__GMM__ATTACH__REQ_combined_defval, L3__Templates::ts__GMM__ATTACH__REQ_follow__on__pending_defval, L3__Templates::ts__GMM__ATTACH__REQ_cm2__tlv_defval, L3__Templates::ts__GMM__ATTACH__REQ_cm3__tlv_defval, nri, L3__Templates::ts__GMM__ATTACH__REQ_p__tmsi__sig_defval, L3__Templates::ts__GMM__ATTACH__REQ_p__tmsi__type_defval, L3__Templates::ts__GMM__ATTACH__REQ_add__p__tmsi_defval, L3__Templates::ts__GMM__ATTACH__REQ_add__rai_defval).valueof());
}
current_location.update_lineno(1799);
/* HNBGW_Tests.ttcn, line 1799 */
if ((compl3type == Compl3Type::RAUREQ)) {
current_location.update_lineno(1800);
/* HNBGW_Tests.ttcn, line 1800 */
return MobileL3__Types::enc__PDU__L3__MS__SGSN(L3__Templates::ts__GMM__RAU__REQ(mi.valueof(), L3__Templates::GprsUpdateType::GPRS__UPD__T__PERIODIC, L3__Common::f__RAI(hs_1, hs_2, os_2, os_3), L3__Templates::ts__GMM__RAU__REQ_follow__on__pending_defval, L3__Templates::ts__GMM__RAU__REQ_cm2__tlv_defval, L3__Templates::ts__GMM__RAU__REQ_cm3__tlv_defval, L3__Templates::ts__GMM__RAU__REQ_p__tmsi_defval, nri, L3__Templates::ts__GMM__RAU__REQ_p__tmsi__sig_defval, L3__Templates::ts__GMM__RAU__REQ_p__tmsi__type_defval, L3__Templates::ts__GMM__RAU__REQ_add__p__tmsi_defval, L3__Templates::ts__GMM__RAU__REQ_add__rai_defval, L3__Templates::ts__GMM__RAU__REQ_ms__network__cap_defval).valueof());
}
current_location.update_lineno(1804);
/* HNBGW_Tests.ttcn, line 1804 */
if ((compl3type == Compl3Type::DETREQ)) {
current_location.update_lineno(1805);
/* HNBGW_Tests.ttcn, line 1805 */
return MobileL3__Types::enc__PDU__L3__MS__SGSN(L3__Templates::ts__GMM__DET__REQ__MO__mi(L3__Templates::c__GMM__DTT__MO__GPRS, FALSE, MobileL3__CommonIE__Types::MobileIdentityTLV_template(L3__Templates::ts__MI__TLV(const_cast< const MobileL3__CommonIE__Types::MobileIdentityLV_template&>(mi).mobileIdentityV()).valueof()), L3__Templates::ts__GMM__DET__REQ__MO__mi_p__tmsi__sig_defval).valueof());
}
current_location.update_lineno(1809);
/* HNBGW_Tests.ttcn, line 1809 */
TTCN_Runtime::setverdict(FAIL,(TTCN_Logger::begin_event_log2str(),TTCN_Logger::log_event_str("unknown complete layer 3 type"),TTCN_Logger::end_event_log2str()));
current_location.update_lineno(1810);
/* HNBGW_Tests.ttcn, line 1810 */
TTCN_Runtime::stop_component(MTC_COMPREF);
}

boolean operator==(null_type, const ro__Compl3Type& other_value)
{
if (other_value.val_ptr == NULL)
TTCN_error("The right operand of comparison is an unbound value of type @HNBGW_Tests.ro_Compl3Type.");
return other_value.val_ptr->n_elements == 0;
}

boolean operator==(null_type, const ro__MobileIdentityLV& other_value)
{
if (other_value.val_ptr == NULL)
TTCN_error("The right operand of comparison is an unbound value of type @HNBGW_Tests.ro_MobileIdentityLV.");
return other_value.val_ptr->n_elements == 0;
}

ro__octetstring f__gen__compl__l3(const ro__Compl3Type& types, const ro__MobileIdentityLV& mis, const INTEGER& n)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1820, TTCN_Location::LOCATION_FUNCTION, "f_gen_compl_l3");
current_location.update_lineno(1822);
/* HNBGW_Tests.ttcn, line 1822 */
ro__octetstring res(NULL_VALUE);
{
current_location.update_lineno(1823);
/* HNBGW_Tests.ttcn, line 1823 */
INTEGER i(0);
current_location.update_lineno(1823);
/* HNBGW_Tests.ttcn, line 1823 */
for ( ; ; ) {
current_location.update_lineno(1823);
/* HNBGW_Tests.ttcn, line 1823 */
if (!(i < n)) break;
current_location.update_lineno(1824);
/* HNBGW_Tests.ttcn, line 1824 */
INTEGER ti(mod(i, types.lengthof()));
current_location.update_lineno(1825);
/* HNBGW_Tests.ttcn, line 1825 */
INTEGER mi(mod(i, mis.lengthof()));
current_location.update_lineno(1826);
/* HNBGW_Tests.ttcn, line 1826 */
res[i] = f__gen__one__compl__l3(const_cast< const ro__Compl3Type&>(types)[ti], MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[mi]), f__gen__one__compl__l3_ps__nri_defval);
current_location.update_lineno(1823);
/* HNBGW_Tests.ttcn, line 1823 */
{
INTEGER tmp_241;
++i;
}
}
}
current_location.update_lineno(1828);
/* HNBGW_Tests.ttcn, line 1828 */
return res;
}

MobileL3__CommonIE__Types::MobileIdentityLV f__gen__mi__imsi(const INTEGER& n)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1831, TTCN_Location::LOCATION_FUNCTION, "f_gen_mi_imsi");
current_location.update_lineno(1833);
/* HNBGW_Tests.ttcn, line 1833 */
return L3__Templates::ts__MI__IMSI__LV(Osmocom__Types::f__gen__imsi(n)).valueof();
}

ro__MobileIdentityLV f__gen__mi__imsis(const INTEGER& n)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1836, TTCN_Location::LOCATION_FUNCTION, "f_gen_mi_imsis");
current_location.update_lineno(1838);
/* HNBGW_Tests.ttcn, line 1838 */
ro__MobileIdentityLV mis(NULL_VALUE);
{
current_location.update_lineno(1839);
/* HNBGW_Tests.ttcn, line 1839 */
INTEGER i(0);
current_location.update_lineno(1839);
/* HNBGW_Tests.ttcn, line 1839 */
for ( ; ; ) {
current_location.update_lineno(1839);
/* HNBGW_Tests.ttcn, line 1839 */
if (!(i < n)) break;
current_location.update_lineno(1840);
/* HNBGW_Tests.ttcn, line 1840 */
mis[i] = f__gen__mi__imsi(n);
current_location.update_lineno(1839);
/* HNBGW_Tests.ttcn, line 1839 */
{
INTEGER tmp_243;
++i;
}
}
}
current_location.update_lineno(1842);
/* HNBGW_Tests.ttcn, line 1842 */
return mis;
}

void f__vty__set__roundrobin__next(TELNETasp__PortType::TELNETasp__PT& VTY, const BOOLEAN& ps__domain, const INTEGER& cn__nr)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1845, TTCN_Location::LOCATION_FUNCTION, "f_vty_set_roundrobin_next");
current_location.update_lineno(1847);
/* HNBGW_Tests.ttcn, line 1847 */
CHARSTRING msc__sgsn;
current_location.update_lineno(1848);
/* HNBGW_Tests.ttcn, line 1848 */
if (ps__domain) {
current_location.update_lineno(1849);
/* HNBGW_Tests.ttcn, line 1849 */
msc__sgsn = cs_18;
}
else {
current_location.update_lineno(1851);
/* HNBGW_Tests.ttcn, line 1851 */
msc__sgsn = cs_19;
}
current_location.update_lineno(1853);
/* HNBGW_Tests.ttcn, line 1853 */
Osmocom__VTY__Functions::f__vty__transceive(VTY, (((cs_71 + msc__sgsn) + cs_21) + int2str(cn__nr)), Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

ro__octetstring f__gen__compl3__by__domain(const BOOLEAN& ps__domain, const INTEGER& n, const ro__MobileIdentityLV_template& mis)
{
ro__MobileIdentityLV_template mis_shadow(mis);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1856, TTCN_Location::LOCATION_FUNCTION, "f_gen_compl3_by_domain");
current_location.update_lineno(1857);
/* HNBGW_Tests.ttcn, line 1857 */
ro__Compl3Type types;
current_location.update_lineno(1858);
/* HNBGW_Tests.ttcn, line 1858 */
if (ps__domain) {
current_location.update_lineno(1859);
/* HNBGW_Tests.ttcn, line 1859 */
types.set_size(3);
types[0] = Compl3Type::ATTACHREQ;
types[1] = Compl3Type::RAUREQ;
types[2] = Compl3Type::DETREQ;
}
else {
current_location.update_lineno(1861);
/* HNBGW_Tests.ttcn, line 1861 */
types.set_size(4);
types[0] = Compl3Type::LU;
types[1] = Compl3Type::CMSERV;
types[2] = Compl3Type::PAGRESP;
types[3] = Compl3Type::IMSIDETACH;
}
current_location.update_lineno(1863);
/* HNBGW_Tests.ttcn, line 1863 */
if (mis_shadow.get_istemplate_kind((const char*)cs_70)) {
current_location.update_lineno(1864);
/* HNBGW_Tests.ttcn, line 1864 */
mis_shadow = f__gen__mi__imsis(n);
}
current_location.update_lineno(1866);
/* HNBGW_Tests.ttcn, line 1866 */
return f__gen__compl__l3(types, mis_shadow.valueof(), n);
}

verdicttype testcase_TC__mscpool__L3Compl__on__1__cnlink(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1870, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_L3Compl_on_1_cnlink");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_L3Compl_on_1_cnlink", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1871);
/* HNBGW_Tests.ttcn, line 1871 */
f__TC__cnpool__L3Compl__on__1__cnlink(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_L3Compl_on_1_cnlink was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__sgsnpool__L3Compl__on__1__cnlink(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1873, TTCN_Location::LOCATION_TESTCASE, "TC_sgsnpool_L3Compl_on_1_cnlink");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sgsnpool_L3Compl_on_1_cnlink", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1874);
/* HNBGW_Tests.ttcn, line 1874 */
f__TC__cnpool__L3Compl__on__1__cnlink(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sgsnpool_L3Compl_on_1_cnlink was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__L3Compl__on__1__cnlink(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1876, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_L3Compl_on_1_cnlink");
current_location.update_lineno(1878);
/* HNBGW_Tests.ttcn, line 1878 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(1880);
/* HNBGW_Tests.ttcn, line 1880 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(1882);
/* HNBGW_Tests.ttcn, line 1882 */
ro__octetstring compl3(f__gen__compl3__by__domain(ps__domain, 4, f__gen__compl3__by__domain_mis_defval));
current_location.update_lineno(1883);
/* HNBGW_Tests.ttcn, line 1883 */
{
Osmocom__Types::ro__integer tmp_249;
tmp_249.set_size(4);
tmp_249[0] = 0;
tmp_249[1] = 0;
tmp_249[2] = 0;
tmp_249[3] = 0;
f__TC__cnpool__compl__l3__list(ps__domain, compl3, tmp_249, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval);
}
current_location.update_lineno(1885);
/* HNBGW_Tests.ttcn, line 1885 */
f__shutdown__helper();
}

void start_f__TC__cnpool__L3Compl__on__1__cnlink(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Compl_on_1_cnlink(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_L3Compl_on_1_cnlink", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__L3Complete__by__imsi__round__robin(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1889, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_L3Complete_by_imsi_round_robin");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_L3Complete_by_imsi_round_robin", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1890);
/* HNBGW_Tests.ttcn, line 1890 */
f__TC__cnpool__L3Complete__by__imsi__round__robin(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_L3Complete_by_imsi_round_robin was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__sgsnpool__L3Complete__no__nri__round__robin(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1892, TTCN_Location::LOCATION_TESTCASE, "TC_sgsnpool_L3Complete_no_nri_round_robin");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sgsnpool_L3Complete_no_nri_round_robin", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1893);
/* HNBGW_Tests.ttcn, line 1893 */
f__TC__cnpool__L3Complete__by__imsi__round__robin(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sgsnpool_L3Complete_no_nri_round_robin was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__L3Complete__by__imsi__round__robin(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1895, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_L3Complete_by_imsi_round_robin");
current_location.update_lineno(1897);
/* HNBGW_Tests.ttcn, line 1897 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 2, 2, f__init_start__hnb_defval);
current_location.update_lineno(1898);
/* HNBGW_Tests.ttcn, line 1898 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1902);
/* HNBGW_Tests.ttcn, line 1902 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(1904);
/* HNBGW_Tests.ttcn, line 1904 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(1906);
/* HNBGW_Tests.ttcn, line 1906 */
ro__octetstring compl3(f__gen__compl3__by__domain(ps__domain, 3, f__gen__compl3__by__domain_mis_defval));
current_location.update_lineno(1908);
/* HNBGW_Tests.ttcn, line 1908 */
{
Osmocom__Types::ro__integer tmp_250;
tmp_250.set_size(3);
tmp_250[0] = 0;
tmp_250[1] = 1;
tmp_250[2] = 0;
f__TC__cnpool__compl__l3__list(ps__domain, compl3, tmp_250, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval);
}
current_location.update_lineno(1913);
/* HNBGW_Tests.ttcn, line 1913 */
f__shutdown__helper();
}

void start_f__TC__cnpool__L3Complete__by__imsi__round__robin(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_by_imsi_round_robin(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_L3Complete_by_imsi_round_robin", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__LU__by__tmsi__null__nri__0__round__robin(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1918, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_LU_by_tmsi_null_nri_0_round_robin");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_LU_by_tmsi_null_nri_0_round_robin", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1919);
/* HNBGW_Tests.ttcn, line 1919 */
f__TC__cnpool__LU__by__tmsi__null__nri__N__round__robin(FALSE, 0);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_LU_by_tmsi_null_nri_0_round_robin was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__mscpool__LU__by__tmsi__null__nri__1__round__robin(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1923, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_LU_by_tmsi_null_nri_1_round_robin");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_LU_by_tmsi_null_nri_1_round_robin", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1924);
/* HNBGW_Tests.ttcn, line 1924 */
f__TC__cnpool__LU__by__tmsi__null__nri__N__round__robin(FALSE, 1);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_LU_by_tmsi_null_nri_1_round_robin was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__LU__by__tmsi__null__nri__N__round__robin(const BOOLEAN& ps__domain, const INTEGER& nri__val)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1926, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_LU_by_tmsi_null_nri_N_round_robin");
current_location.update_lineno(1928);
/* HNBGW_Tests.ttcn, line 1928 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 2, 2, f__init_start__hnb_defval);
current_location.update_lineno(1929);
/* HNBGW_Tests.ttcn, line 1929 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1933);
/* HNBGW_Tests.ttcn, line 1933 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(1935);
/* HNBGW_Tests.ttcn, line 1935 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(1937);
/* HNBGW_Tests.ttcn, line 1937 */
ro__MobileIdentityLV mis;
mis.set_size(1);
mis[0] = L3__Templates::ts__MI__TMSI__NRI__LV(nri__val, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
current_location.update_lineno(1938);
/* HNBGW_Tests.ttcn, line 1938 */
ro__octetstring compl3;
current_location.update_lineno(1939);
/* HNBGW_Tests.ttcn, line 1939 */
if (ps__domain) {
current_location.update_lineno(1940);
/* HNBGW_Tests.ttcn, line 1940 */
compl3.set_size(1);
compl3[0] = f__gen__one__compl__l3(Compl3Type::ATTACHREQ, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[0]), nri__val);
}
else {
current_location.update_lineno(1944);
/* HNBGW_Tests.ttcn, line 1944 */
ro__Compl3Type tmp_253;
tmp_253.set_size(1);
tmp_253[0] = Compl3Type::LU;
compl3 = f__gen__compl__l3(tmp_253, mis, 1);
}
current_location.update_lineno(1947);
/* HNBGW_Tests.ttcn, line 1947 */
{
Osmocom__Types::ro__integer tmp_254;
tmp_254.set_size(3);
tmp_254[0] = 0;
tmp_254[1] = 1;
tmp_254[2] = 0;
f__TC__cnpool__compl__l3__list(ps__domain, compl3, tmp_254, CHARSTRING_template(cs_65), f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval);
}
current_location.update_lineno(1951);
/* HNBGW_Tests.ttcn, line 1951 */
f__shutdown__helper();
}

void start_f__TC__cnpool__LU__by__tmsi__null__nri__N__round__robin(const COMPONENT& component_reference, const BOOLEAN& ps__domain, const INTEGER& nri__val)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_LU_by_tmsi_null_nri_N_round_robin(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
nri__val.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_LU_by_tmsi_null_nri_N_round_robin", text_buf);
ps__domain.encode_text(text_buf);
nri__val.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__L3Complete__by__tmsi__unassigned__nri__round__robin(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1956, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_L3Complete_by_tmsi_unassigned_nri_round_robin");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_L3Complete_by_tmsi_unassigned_nri_round_robin", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1957);
/* HNBGW_Tests.ttcn, line 1957 */
f__TC__cnpool__L3Complete__by__tmsi__unassigned__nri__round__robin(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_L3Complete_by_tmsi_unassigned_nri_round_robin was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__L3Complete__by__tmsi__unassigned__nri__round__robin(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1959, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_L3Complete_by_tmsi_unassigned_nri_round_robin");
current_location.update_lineno(1961);
/* HNBGW_Tests.ttcn, line 1961 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 2, 2, f__init_start__hnb_defval);
current_location.update_lineno(1962);
/* HNBGW_Tests.ttcn, line 1962 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1966);
/* HNBGW_Tests.ttcn, line 1966 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(1968);
/* HNBGW_Tests.ttcn, line 1968 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(1971);
/* HNBGW_Tests.ttcn, line 1971 */
ro__MobileIdentityLV mis;
mis.set_size(3);
mis[0] = L3__Templates::ts__MI__TMSI__NRI__LV(1000, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[1] = L3__Templates::ts__MI__TMSI__NRI__LV(768, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[2] = L3__Templates::ts__MI__TMSI__NRI__LV(819, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
current_location.update_lineno(1977);
/* HNBGW_Tests.ttcn, line 1977 */
ro__octetstring compl3(f__gen__compl3__by__domain(ps__domain, 3, ro__MobileIdentityLV_template(mis)));
current_location.update_lineno(1978);
/* HNBGW_Tests.ttcn, line 1978 */
{
Osmocom__Types::ro__integer tmp_255;
tmp_255.set_size(3);
tmp_255[0] = 0;
tmp_255[1] = 1;
tmp_255[2] = 0;
f__TC__cnpool__compl__l3__list(ps__domain, compl3, tmp_255, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval);
}
current_location.update_lineno(1980);
/* HNBGW_Tests.ttcn, line 1980 */
f__shutdown__helper();
}

void start_f__TC__cnpool__L3Complete__by__tmsi__unassigned__nri__round__robin(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_by_tmsi_unassigned_nri_round_robin(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_L3Complete_by_tmsi_unassigned_nri_round_robin", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 1985, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(1986);
/* HNBGW_Tests.ttcn, line 1986 */
f__TC__cnpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 1988, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin");
current_location.update_lineno(1990);
/* HNBGW_Tests.ttcn, line 1990 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 2, 2, f__init_start__hnb_defval);
current_location.update_lineno(1991);
/* HNBGW_Tests.ttcn, line 1991 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(1995);
/* HNBGW_Tests.ttcn, line 1995 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(1997);
/* HNBGW_Tests.ttcn, line 1997 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2000);
/* HNBGW_Tests.ttcn, line 2000 */
ro__MobileIdentityLV mis;
mis.set_size(3);
mis[0] = L3__Templates::ts__MI__TMSI__NRI__LV(512, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[1] = L3__Templates::ts__MI__TMSI__NRI__LV(767, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[2] = L3__Templates::ts__MI__TMSI__NRI__LV(750, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
current_location.update_lineno(2006);
/* HNBGW_Tests.ttcn, line 2006 */
ro__octetstring compl3(f__gen__compl3__by__domain(ps__domain, 3, ro__MobileIdentityLV_template(mis)));
current_location.update_lineno(2008);
/* HNBGW_Tests.ttcn, line 2008 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[0], 0, f__TC__cnpool__compl__l3_inc__countername_defval, f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2009);
/* HNBGW_Tests.ttcn, line 2009 */
f__ctrs__cn__add(2, cs_66, f__ctrs__cn__add_val_defval);
current_location.update_lineno(2010);
/* HNBGW_Tests.ttcn, line 2010 */
f__ctrs__cn__add(0, cs_63, f__ctrs__cn__add_val_defval);
current_location.update_lineno(2011);
/* HNBGW_Tests.ttcn, line 2011 */
f__ctrs__cn__verify();
current_location.update_lineno(2013);
/* HNBGW_Tests.ttcn, line 2013 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[1], 1, f__TC__cnpool__compl__l3_inc__countername_defval, f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2014);
/* HNBGW_Tests.ttcn, line 2014 */
f__ctrs__cn__add(2, cs_66, f__ctrs__cn__add_val_defval);
current_location.update_lineno(2015);
/* HNBGW_Tests.ttcn, line 2015 */
f__ctrs__cn__add(1, cs_63, f__ctrs__cn__add_val_defval);
current_location.update_lineno(2016);
/* HNBGW_Tests.ttcn, line 2016 */
f__ctrs__cn__verify();
current_location.update_lineno(2018);
/* HNBGW_Tests.ttcn, line 2018 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[2], 0, f__TC__cnpool__compl__l3_inc__countername_defval, f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2019);
/* HNBGW_Tests.ttcn, line 2019 */
f__ctrs__cn__add(2, cs_66, f__ctrs__cn__add_val_defval);
current_location.update_lineno(2020);
/* HNBGW_Tests.ttcn, line 2020 */
f__ctrs__cn__add(0, cs_63, f__ctrs__cn__add_val_defval);
current_location.update_lineno(2021);
/* HNBGW_Tests.ttcn, line 2021 */
f__ctrs__cn__verify();
current_location.update_lineno(2023);
/* HNBGW_Tests.ttcn, line 2023 */
f__shutdown__helper();
}

void start_f__TC__cnpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__1(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2028, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_L3Complete_by_tmsi_valid_nri_1");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_L3Complete_by_tmsi_valid_nri_1", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2029);
/* HNBGW_Tests.ttcn, line 2029 */
f__TC__cnpool__L3Complete__valid__nri__1(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_L3Complete_by_tmsi_valid_nri_1 was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__sgsnpool__L3Complete__valid__nri__1(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2031, TTCN_Location::LOCATION_TESTCASE, "TC_sgsnpool_L3Complete_valid_nri_1");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sgsnpool_L3Complete_valid_nri_1", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2032);
/* HNBGW_Tests.ttcn, line 2032 */
f__TC__cnpool__L3Complete__valid__nri__1(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sgsnpool_L3Complete_valid_nri_1 was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__L3Complete__valid__nri__1(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2034, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_L3Complete_valid_nri_1");
current_location.update_lineno(2036);
/* HNBGW_Tests.ttcn, line 2036 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 2, 2, f__init_start__hnb_defval);
current_location.update_lineno(2037);
/* HNBGW_Tests.ttcn, line 2037 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2041);
/* HNBGW_Tests.ttcn, line 2041 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2043);
/* HNBGW_Tests.ttcn, line 2043 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2045);
/* HNBGW_Tests.ttcn, line 2045 */
ro__octetstring compl3;
current_location.update_lineno(2048);
/* HNBGW_Tests.ttcn, line 2048 */
ro__MobileIdentityLV mis;
mis.set_size(3);
mis[0] = L3__Templates::ts__MI__TMSI__NRI__LV(256, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[1] = L3__Templates::ts__MI__TMSI__NRI__LV(260, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[2] = L3__Templates::ts__MI__TMSI__NRI__LV(511, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
current_location.update_lineno(2053);
/* HNBGW_Tests.ttcn, line 2053 */
if (ps__domain) {
current_location.update_lineno(2054);
/* HNBGW_Tests.ttcn, line 2054 */
compl3.set_size(3);
compl3[0] = f__gen__one__compl__l3(Compl3Type::RAUREQ, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[0]), 256);
compl3[1] = f__gen__one__compl__l3(Compl3Type::RAUREQ, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[1]), 260);
compl3[2] = f__gen__one__compl__l3(Compl3Type::RAUREQ, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[2]), 511);
}
else {
current_location.update_lineno(2060);
/* HNBGW_Tests.ttcn, line 2060 */
compl3 = f__gen__compl3__by__domain(ps__domain, 3, ro__MobileIdentityLV_template(mis));
}
current_location.update_lineno(2063);
/* HNBGW_Tests.ttcn, line 2063 */
{
Osmocom__Types::ro__integer tmp_258;
tmp_258.set_size(3);
tmp_258[0] = 1;
tmp_258[1] = 1;
tmp_258[2] = 1;
f__TC__cnpool__compl__l3__list(ps__domain, compl3, tmp_258, CHARSTRING_template(cs_64), f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval);
}
current_location.update_lineno(2065);
/* HNBGW_Tests.ttcn, line 2065 */
f__shutdown__helper();
}

void start_f__TC__cnpool__L3Complete__valid__nri__1(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_valid_nri_1(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_L3Complete_valid_nri_1", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__2(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2070, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_L3Complete_by_tmsi_valid_nri_2");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_L3Complete_by_tmsi_valid_nri_2", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2071);
/* HNBGW_Tests.ttcn, line 2071 */
f__TC__cnpool__L3Complete__valid__nri__2(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_L3Complete_by_tmsi_valid_nri_2 was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__sgsnpool__L3Complete__valid__nri__2(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2073, TTCN_Location::LOCATION_TESTCASE, "TC_sgsnpool_L3Complete_valid_nri_2");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sgsnpool_L3Complete_valid_nri_2", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2074);
/* HNBGW_Tests.ttcn, line 2074 */
f__TC__cnpool__L3Complete__valid__nri__2(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sgsnpool_L3Complete_valid_nri_2 was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__L3Complete__valid__nri__2(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2076, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_L3Complete_valid_nri_2");
current_location.update_lineno(2078);
/* HNBGW_Tests.ttcn, line 2078 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 3, 3, f__init_start__hnb_defval);
current_location.update_lineno(2079);
/* HNBGW_Tests.ttcn, line 2079 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2083);
/* HNBGW_Tests.ttcn, line 2083 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 1);
current_location.update_lineno(2085);
/* HNBGW_Tests.ttcn, line 2085 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2087);
/* HNBGW_Tests.ttcn, line 2087 */
ro__octetstring compl3;
current_location.update_lineno(2090);
/* HNBGW_Tests.ttcn, line 2090 */
ro__MobileIdentityLV mis;
mis.set_size(2);
mis[0] = L3__Templates::ts__MI__TMSI__NRI__LV(512, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[1] = L3__Templates::ts__MI__TMSI__NRI__LV(678, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
current_location.update_lineno(2094);
/* HNBGW_Tests.ttcn, line 2094 */
if (ps__domain) {
current_location.update_lineno(2095);
/* HNBGW_Tests.ttcn, line 2095 */
compl3.set_size(2);
compl3[0] = f__gen__one__compl__l3(Compl3Type::ATTACHREQ, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[0]), 512);
compl3[1] = f__gen__one__compl__l3(Compl3Type::ATTACHREQ, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[1]), 678);
}
else {
current_location.update_lineno(2100);
/* HNBGW_Tests.ttcn, line 2100 */
compl3 = f__gen__compl3__by__domain(ps__domain, 2, ro__MobileIdentityLV_template(mis));
}
current_location.update_lineno(2103);
/* HNBGW_Tests.ttcn, line 2103 */
{
Osmocom__Types::ro__integer tmp_261;
tmp_261.set_size(2);
tmp_261[0] = 2;
tmp_261[1] = 2;
f__TC__cnpool__compl__l3__list(ps__domain, compl3, tmp_261, CHARSTRING_template(cs_64), f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval);
}
current_location.update_lineno(2106);
/* HNBGW_Tests.ttcn, line 2106 */
{
Osmocom__Types::ro__integer tmp_262;
tmp_262.set_size(1);
tmp_262[0] = 1;
f__TC__cnpool__compl__l3__list(ps__domain, f__gen__compl3__by__domain(ps__domain, 1, f__gen__compl3__by__domain_mis_defval), tmp_262, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval);
}
current_location.update_lineno(2108);
/* HNBGW_Tests.ttcn, line 2108 */
f__shutdown__helper();
}

void start_f__TC__cnpool__L3Complete__valid__nri__2(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_valid_nri_2(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_L3Complete_valid_nri_2", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__LU__by__tmsi__from__other__PLMN(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2112, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_LU_by_tmsi_from_other_PLMN");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_LU_by_tmsi_from_other_PLMN", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2113);
/* HNBGW_Tests.ttcn, line 2113 */
f__TC__cnpool__nri__from__other__PLMN(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_LU_by_tmsi_from_other_PLMN was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__sgsnpool__nri__from__other__PLMN(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2115, TTCN_Location::LOCATION_TESTCASE, "TC_sgsnpool_nri_from_other_PLMN");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sgsnpool_nri_from_other_PLMN", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2116);
/* HNBGW_Tests.ttcn, line 2116 */
f__TC__cnpool__nri__from__other__PLMN(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sgsnpool_nri_from_other_PLMN was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__nri__from__other__PLMN(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2118, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_nri_from_other_PLMN");
current_location.update_lineno(2120);
/* HNBGW_Tests.ttcn, line 2120 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 3, 3, f__init_start__hnb_defval);
current_location.update_lineno(2121);
/* HNBGW_Tests.ttcn, line 2121 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2125);
/* HNBGW_Tests.ttcn, line 2125 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2127);
/* HNBGW_Tests.ttcn, line 2127 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2129);
/* HNBGW_Tests.ttcn, line 2129 */
ro__octetstring compl3;
current_location.update_lineno(2131);
/* HNBGW_Tests.ttcn, line 2131 */
ro__MobileIdentityLV mis;
mis.set_size(2);
mis[0] = L3__Templates::ts__MI__TMSI__NRI__LV(260, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[1] = L3__Templates::ts__MI__TMSI__NRI__LV(555, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
current_location.update_lineno(2135);
/* HNBGW_Tests.ttcn, line 2135 */
if (ps__domain) {
current_location.update_lineno(2136);
/* HNBGW_Tests.ttcn, line 2136 */
compl3.set_size(2);
compl3[0] = MobileL3__Types::enc__PDU__L3__MS__SGSN(L3__Templates::ts__GMM__ATTACH__REQ(const_cast< const ro__MobileIdentityLV&>(mis)[0], L3__Common::f__RAI(hs_3, hs_4, os_2, os_3), L3__Templates::ts__GMM__ATTACH__REQ_combined_defval, L3__Templates::ts__GMM__ATTACH__REQ_follow__on__pending_defval, L3__Templates::ts__GMM__ATTACH__REQ_cm2__tlv_defval, L3__Templates::ts__GMM__ATTACH__REQ_cm3__tlv_defval, L3__Templates::ts__GMM__NRI(260), L3__Templates::ts__GMM__ATTACH__REQ_p__tmsi__sig_defval, L3__Templates::ts__GMM__ATTACH__REQ_p__tmsi__type_defval, L3__Templates::ts__GMM__ATTACH__REQ_add__p__tmsi_defval, L3__Templates::ts__GMM__ATTACH__REQ_add__rai_defval).valueof());
compl3[1] = f__gen__one__compl__l3(Compl3Type::ATTACHREQ, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[1]), 555);
}
else {
current_location.update_lineno(2146);
/* HNBGW_Tests.ttcn, line 2146 */
compl3.set_size(2);
compl3[0] = MobileL3__Types::enc__PDU__ML3__MS__NW(L3__Templates::ts__LU__REQ(L3__Templates::LU__Type__IMSI__Attach, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[0]), OCTETSTRING_template(os_4)).valueof());
compl3[1] = MobileL3__Types::enc__PDU__ML3__MS__NW(L3__Templates::ts__LU__REQ(L3__Templates::LU__Type__IMSI__Attach, MobileL3__CommonIE__Types::MobileIdentityLV_template(const_cast< const ro__MobileIdentityLV&>(mis)[1]), OCTETSTRING_template(os_0)).valueof());
}
current_location.update_lineno(2155);
/* HNBGW_Tests.ttcn, line 2155 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[0], 0, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2158);
/* HNBGW_Tests.ttcn, line 2158 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[1], 2, CHARSTRING_template(cs_64), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2160);
/* HNBGW_Tests.ttcn, line 2160 */
f__shutdown__helper();
}

void start_f__TC__cnpool__nri__from__other__PLMN(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_nri_from_other_PLMN(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_nri_from_other_PLMN", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__tc__mscpool__paging__imsi(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2165, TTCN_Location::LOCATION_FUNCTION, "f_tc_mscpool_paging_imsi");
current_location.update_lineno(2166);
/* HNBGW_Tests.ttcn, line 2166 */
HEXSTRING imsi(hs_5);
current_location.update_lineno(2167);
/* HNBGW_Tests.ttcn, line 2167 */
RANAP__IEs::CN__DomainIndicator domain__ind;
current_location.update_lineno(2168);
/* HNBGW_Tests.ttcn, line 2168 */
if (const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).ps__domain()) {
current_location.update_lineno(2169);
/* HNBGW_Tests.ttcn, line 2169 */
domain__ind = RANAP__IEs::CN__DomainIndicator::ps__domain;
}
else {
current_location.update_lineno(2171);
/* HNBGW_Tests.ttcn, line 2171 */
domain__ind = RANAP__IEs::CN__DomainIndicator::cs__domain;
}
current_location.update_lineno(2173);
/* HNBGW_Tests.ttcn, line 2173 */
RANAP__PDU__Descriptions::RANAP__PDU_template paging(RANAP__Templates::ts__RANAP__Paging(RANAP__IEs::CN__DomainIndicator_template(domain__ind), OCTETSTRING_template(Osmocom__Types::imsi__hex2oct(imsi)), RANAP__Templates::ts__RANAP__Paging_exts_defval));
current_location.update_lineno(2174);
/* HNBGW_Tests.ttcn, line 2174 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(RANAP__CodecPort::ts__RANAP__UNITDATA__req(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).sccp__addr__hnbgw(), const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).sccp__addr__msc(), paging), FALSE, NULL);
current_location.update_lineno(2181);
/* HNBGW_Tests.ttcn, line 2181 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2185);
/* HNBGW_Tests.ttcn, line 2185 */
ConnHdlr::f__perform__compl__l3(f__gen__one__compl__l3(Compl3Type::PAGRESP, L3__Templates::ts__MI__IMSI__LV(imsi), f__gen__one__compl__l3_ps__nri_defval), ConnHdlr::f__perform__compl__l3_do__clear_defval, ConnHdlr::f__perform__compl__l3_expect__success_defval);
current_location.update_lineno(2186);
/* HNBGW_Tests.ttcn, line 2186 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__tc__mscpool__paging__imsi(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_mscpool_paging_imsi(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_mscpool_paging_imsi", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__paging__imsi(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2189, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_paging_imsi");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_paging_imsi", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2190);
/* HNBGW_Tests.ttcn, line 2190 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 3, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2191);
/* HNBGW_Tests.ttcn, line 2191 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2193);
/* HNBGW_Tests.ttcn, line 2193 */
BOOLEAN ps__domain(FALSE);
current_location.update_lineno(2197);
/* HNBGW_Tests.ttcn, line 2197 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2199);
/* HNBGW_Tests.ttcn, line 2199 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2201);
/* HNBGW_Tests.ttcn, line 2201 */
COMPONENT vc__conn1;
current_location.update_lineno(2202);
/* HNBGW_Tests.ttcn, line 2202 */
ConnHdlr::TestHdlrParams_template pars1(f__TestHdlrParams(0, ps__domain, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, 0, f__TestHdlrParams_rab__rel__cause_defval));
current_location.update_lineno(2203);
/* HNBGW_Tests.ttcn, line 2203 */
vc__conn1 = f__start__handler__with__pars(&f__tc__mscpool__paging__imsi, pars1);
current_location.update_lineno(2204);
/* HNBGW_Tests.ttcn, line 2204 */
{
tmp_268:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn1.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_268;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_268;
}
current_location.update_lineno(2204);
/* HNBGW_Tests.ttcn, line 2204 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 2204.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2205);
/* HNBGW_Tests.ttcn, line 2205 */
f__ctrs__cn__expect(0, cs_67, f__ctrs__cn__expect_val_defval);
current_location.update_lineno(2206);
/* HNBGW_Tests.ttcn, line 2206 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_paging_imsi was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__mscpool__paging__tmsi(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2211, TTCN_Location::LOCATION_FUNCTION, "f_tc_mscpool_paging_tmsi");
current_location.update_lineno(2212);
/* HNBGW_Tests.ttcn, line 2212 */
HEXSTRING imsi(hs_6);
current_location.update_lineno(2213);
/* HNBGW_Tests.ttcn, line 2213 */
INTEGER nri__v(300);
current_location.update_lineno(2214);
/* HNBGW_Tests.ttcn, line 2214 */
OCTETSTRING tmsi(Osmocom__Types::f__gen__tmsi(0, nri__v, Osmocom__Types::f__gen__tmsi_nri__bitlen_defval, Osmocom__Types::f__gen__tmsi_base__tmsi_defval));
current_location.update_lineno(2216);
/* HNBGW_Tests.ttcn, line 2216 */
RANAP__IEs::CN__DomainIndicator domain__ind;
current_location.update_lineno(2217);
/* HNBGW_Tests.ttcn, line 2217 */
if (const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).ps__domain()) {
current_location.update_lineno(2218);
/* HNBGW_Tests.ttcn, line 2218 */
domain__ind = RANAP__IEs::CN__DomainIndicator::ps__domain;
}
else {
current_location.update_lineno(2220);
/* HNBGW_Tests.ttcn, line 2220 */
domain__ind = RANAP__IEs::CN__DomainIndicator::cs__domain;
}
current_location.update_lineno(2222);
/* HNBGW_Tests.ttcn, line 2222 */
RANAP__PDU__Descriptions::RANAP__PDU_template paging(RANAP__Templates::ts__RANAP__Paging__temp__id(RANAP__IEs::CN__DomainIndicator_template(domain__ind), OCTETSTRING_template(Osmocom__Types::imsi__hex2oct(imsi)), RANAP__Templates::ts__RANAP__TemporaryUE__ID__TMSI(tmsi), RANAP__Templates::ts__RANAP__Paging__temp__id_exts_defval));
current_location.update_lineno(2224);
/* HNBGW_Tests.ttcn, line 2224 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(RANAP__CodecPort::ts__RANAP__UNITDATA__req(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).sccp__addr__hnbgw(), const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).sccp__addr__msc(), paging), FALSE, NULL);
current_location.update_lineno(2231);
/* HNBGW_Tests.ttcn, line 2231 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2235);
/* HNBGW_Tests.ttcn, line 2235 */
ConnHdlr::f__perform__compl__l3(f__gen__one__compl__l3(Compl3Type::PAGRESP, L3__Templates::ts__MI__TMSI__NRI__LV(nri__v, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval), f__gen__one__compl__l3_ps__nri_defval), ConnHdlr::f__perform__compl__l3_do__clear_defval, ConnHdlr::f__perform__compl__l3_expect__success_defval);
current_location.update_lineno(2236);
/* HNBGW_Tests.ttcn, line 2236 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__tc__mscpool__paging__tmsi(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_mscpool_paging_tmsi(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_mscpool_paging_tmsi", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__paging__tmsi(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2238, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_paging_tmsi");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_paging_tmsi", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2239);
/* HNBGW_Tests.ttcn, line 2239 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 3, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2240);
/* HNBGW_Tests.ttcn, line 2240 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2242);
/* HNBGW_Tests.ttcn, line 2242 */
BOOLEAN ps__domain(FALSE);
current_location.update_lineno(2246);
/* HNBGW_Tests.ttcn, line 2246 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2248);
/* HNBGW_Tests.ttcn, line 2248 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2250);
/* HNBGW_Tests.ttcn, line 2250 */
COMPONENT vc__conn1;
current_location.update_lineno(2251);
/* HNBGW_Tests.ttcn, line 2251 */
ConnHdlr::TestHdlrParams_template pars1(f__TestHdlrParams(0, ps__domain, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, 0, f__TestHdlrParams_rab__rel__cause_defval));
current_location.update_lineno(2252);
/* HNBGW_Tests.ttcn, line 2252 */
vc__conn1 = f__start__handler__with__pars(&f__tc__mscpool__paging__tmsi, pars1);
current_location.update_lineno(2253);
/* HNBGW_Tests.ttcn, line 2253 */
{
tmp_272:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn1.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_272;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_272;
}
current_location.update_lineno(2253);
/* HNBGW_Tests.ttcn, line 2253 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 2253.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2254);
/* HNBGW_Tests.ttcn, line 2254 */
f__ctrs__cn__expect(0, cs_67, f__ctrs__cn__expect_val_defval);
current_location.update_lineno(2255);
/* HNBGW_Tests.ttcn, line 2255 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_paging_tmsi was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__mscpool__paging__imsi__lai__registered(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2260, TTCN_Location::LOCATION_FUNCTION, "f_tc_mscpool_paging_imsi_lai_registered");
current_location.update_lineno(2261);
/* HNBGW_Tests.ttcn, line 2261 */
HEXSTRING imsi(hs_5);
current_location.update_lineno(2262);
/* HNBGW_Tests.ttcn, line 2262 */
RANAP__IEs::CN__DomainIndicator domain__ind;
current_location.update_lineno(2263);
/* HNBGW_Tests.ttcn, line 2263 */
RANAP__IEs::LAI_template lai(RANAP__Templates::ts__RANAP__LAI(OCTETSTRING_template(hex2oct(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()().lai().mcc__mnc())), OCTETSTRING_template(int2oct(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()().lai().lac(), 2))));
current_location.update_lineno(2265);
/* HNBGW_Tests.ttcn, line 2265 */
RANAP__IEs::PagingAreaID_template pag__area__id(RANAP__Templates::ts__RANAP__PagingAreaID__LAI(lai));
current_location.update_lineno(2266);
/* HNBGW_Tests.ttcn, line 2266 */
if (const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).ps__domain()) {
current_location.update_lineno(2267);
/* HNBGW_Tests.ttcn, line 2267 */
domain__ind = RANAP__IEs::CN__DomainIndicator::ps__domain;
}
else {
current_location.update_lineno(2269);
/* HNBGW_Tests.ttcn, line 2269 */
domain__ind = RANAP__IEs::CN__DomainIndicator::cs__domain;
}
current_location.update_lineno(2271);
/* HNBGW_Tests.ttcn, line 2271 */
RANAP__PDU__Descriptions::RANAP__PDU_template paging(RANAP__Templates::ts__RANAP__Paging__pag__area__id(RANAP__IEs::CN__DomainIndicator_template(domain__ind), OCTETSTRING_template(Osmocom__Types::imsi__hex2oct(imsi)), pag__area__id, RANAP__Templates::ts__RANAP__Paging__pag__area__id_exts_defval));
current_location.update_lineno(2272);
/* HNBGW_Tests.ttcn, line 2272 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(RANAP__CodecPort::ts__RANAP__UNITDATA__req(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).sccp__addr__hnbgw(), const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).sccp__addr__msc(), paging), FALSE, NULL);
current_location.update_lineno(2279);
/* HNBGW_Tests.ttcn, line 2279 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2283);
/* HNBGW_Tests.ttcn, line 2283 */
ConnHdlr::f__perform__compl__l3(f__gen__one__compl__l3(Compl3Type::PAGRESP, L3__Templates::ts__MI__IMSI__LV(imsi), f__gen__one__compl__l3_ps__nri_defval), ConnHdlr::f__perform__compl__l3_do__clear_defval, ConnHdlr::f__perform__compl__l3_expect__success_defval);
current_location.update_lineno(2284);
/* HNBGW_Tests.ttcn, line 2284 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__tc__mscpool__paging__imsi__lai__registered(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_mscpool_paging_imsi_lai_registered(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_mscpool_paging_imsi_lai_registered", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__paging__imsi__lai__registered(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2288, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_paging_imsi_lai_registered");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_paging_imsi_lai_registered", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2289);
/* HNBGW_Tests.ttcn, line 2289 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 3, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2290);
/* HNBGW_Tests.ttcn, line 2290 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2292);
/* HNBGW_Tests.ttcn, line 2292 */
BOOLEAN ps__domain(FALSE);
current_location.update_lineno(2296);
/* HNBGW_Tests.ttcn, line 2296 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2298);
/* HNBGW_Tests.ttcn, line 2298 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2300);
/* HNBGW_Tests.ttcn, line 2300 */
COMPONENT vc__conn1;
current_location.update_lineno(2301);
/* HNBGW_Tests.ttcn, line 2301 */
ConnHdlr::TestHdlrParams_template pars1(f__TestHdlrParams(0, ps__domain, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, 0, f__TestHdlrParams_rab__rel__cause_defval));
current_location.update_lineno(2302);
/* HNBGW_Tests.ttcn, line 2302 */
vc__conn1 = f__start__handler__with__pars(&f__tc__mscpool__paging__imsi__lai__registered, pars1);
current_location.update_lineno(2303);
/* HNBGW_Tests.ttcn, line 2303 */
{
tmp_276:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn1.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_276;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_276;
}
current_location.update_lineno(2303);
/* HNBGW_Tests.ttcn, line 2303 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 2303.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2304);
/* HNBGW_Tests.ttcn, line 2304 */
f__ctrs__cn__expect(0, cs_67, f__ctrs__cn__expect_val_defval);
current_location.update_lineno(2305);
/* HNBGW_Tests.ttcn, line 2305 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_paging_imsi_lai_registered was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__mscpool__paging__imsi__rai__registered(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2310, TTCN_Location::LOCATION_FUNCTION, "f_tc_mscpool_paging_imsi_rai_registered");
current_location.update_lineno(2311);
/* HNBGW_Tests.ttcn, line 2311 */
HEXSTRING imsi(hs_5);
current_location.update_lineno(2312);
/* HNBGW_Tests.ttcn, line 2312 */
RANAP__IEs::CN__DomainIndicator domain__ind;
current_location.update_lineno(2313);
/* HNBGW_Tests.ttcn, line 2313 */
RANAP__IEs::LAI_template lai(RANAP__Templates::ts__RANAP__LAI(OCTETSTRING_template(hex2oct(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()().lai().mcc__mnc())), OCTETSTRING_template(int2oct(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()().lai().lac(), 2))));
current_location.update_lineno(2315);
/* HNBGW_Tests.ttcn, line 2315 */
RANAP__IEs::RAI_template rai(RANAP__Templates::ts__RANAP__RAI(lai, OCTETSTRING_template(int2oct(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).hnb()().rac(), 1))));
current_location.update_lineno(2317);
/* HNBGW_Tests.ttcn, line 2317 */
RANAP__IEs::PagingAreaID_template pag__area__id(RANAP__Templates::ts__RANAP__PagingAreaID__RAI(rai));
current_location.update_lineno(2318);
/* HNBGW_Tests.ttcn, line 2318 */
if (const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).ps__domain()) {
current_location.update_lineno(2319);
/* HNBGW_Tests.ttcn, line 2319 */
domain__ind = RANAP__IEs::CN__DomainIndicator::ps__domain;
}
else {
current_location.update_lineno(2321);
/* HNBGW_Tests.ttcn, line 2321 */
domain__ind = RANAP__IEs::CN__DomainIndicator::cs__domain;
}
current_location.update_lineno(2323);
/* HNBGW_Tests.ttcn, line 2323 */
RANAP__PDU__Descriptions::RANAP__PDU_template paging(RANAP__Templates::ts__RANAP__Paging__pag__area__id(RANAP__IEs::CN__DomainIndicator_template(domain__ind), OCTETSTRING_template(Osmocom__Types::imsi__hex2oct(imsi)), pag__area__id, RANAP__Templates::ts__RANAP__Paging__pag__area__id_exts_defval));
current_location.update_lineno(2324);
/* HNBGW_Tests.ttcn, line 2324 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(RANAP__CodecPort::ts__RANAP__UNITDATA__req(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).sccp__addr__hnbgw(), const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).sccp__addr__msc(), paging), FALSE, NULL);
current_location.update_lineno(2331);
/* HNBGW_Tests.ttcn, line 2331 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2335);
/* HNBGW_Tests.ttcn, line 2335 */
ConnHdlr::f__perform__compl__l3(f__gen__one__compl__l3(Compl3Type::PAGRESP, L3__Templates::ts__MI__IMSI__LV(imsi), f__gen__one__compl__l3_ps__nri_defval), ConnHdlr::f__perform__compl__l3_do__clear_defval, ConnHdlr::f__perform__compl__l3_expect__success_defval);
current_location.update_lineno(2336);
/* HNBGW_Tests.ttcn, line 2336 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__tc__mscpool__paging__imsi__rai__registered(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_mscpool_paging_imsi_rai_registered(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_mscpool_paging_imsi_rai_registered", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__paging__imsi__rai__registered(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2340, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_paging_imsi_rai_registered");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_paging_imsi_rai_registered", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2341);
/* HNBGW_Tests.ttcn, line 2341 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 3, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2342);
/* HNBGW_Tests.ttcn, line 2342 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2344);
/* HNBGW_Tests.ttcn, line 2344 */
BOOLEAN ps__domain(TRUE);
current_location.update_lineno(2348);
/* HNBGW_Tests.ttcn, line 2348 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2350);
/* HNBGW_Tests.ttcn, line 2350 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2352);
/* HNBGW_Tests.ttcn, line 2352 */
COMPONENT vc__conn1;
current_location.update_lineno(2353);
/* HNBGW_Tests.ttcn, line 2353 */
ConnHdlr::TestHdlrParams_template pars1(f__TestHdlrParams(0, ps__domain, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, 0, f__TestHdlrParams_rab__rel__cause_defval));
current_location.update_lineno(2354);
/* HNBGW_Tests.ttcn, line 2354 */
vc__conn1 = f__start__handler__with__pars(&f__tc__mscpool__paging__imsi__rai__registered, pars1);
current_location.update_lineno(2355);
/* HNBGW_Tests.ttcn, line 2355 */
{
tmp_280:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn1.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_280;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_280;
}
current_location.update_lineno(2355);
/* HNBGW_Tests.ttcn, line 2355 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 2355.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2356);
/* HNBGW_Tests.ttcn, line 2356 */
f__ctrs__cn__expect(0, cs_67, f__ctrs__cn__expect_val_defval);
current_location.update_lineno(2357);
/* HNBGW_Tests.ttcn, line 2357 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_paging_imsi_rai_registered was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__mscpool__no__allow__attach__round__robin(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2361, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_no_allow_attach_round_robin");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_no_allow_attach_round_robin", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2363);
/* HNBGW_Tests.ttcn, line 2363 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 3, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2364);
/* HNBGW_Tests.ttcn, line 2364 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2366);
/* HNBGW_Tests.ttcn, line 2366 */
BOOLEAN ps__domain(FALSE);
current_location.update_lineno(2369);
/* HNBGW_Tests.ttcn, line 2369 */
{
BooleanList tmp_281;
tmp_281.set_size(3);
tmp_281[0] = TRUE;
tmp_281[1] = FALSE;
tmp_281[2] = TRUE;
f__vty__cnlink__allow__attach(test__CT_component_HNBGWVTY, ps__domain, tmp_281);
}
current_location.update_lineno(2373);
/* HNBGW_Tests.ttcn, line 2373 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2375);
/* HNBGW_Tests.ttcn, line 2375 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2377);
/* HNBGW_Tests.ttcn, line 2377 */
{
Osmocom__Types::ro__integer tmp_282;
tmp_282.set_size(3);
tmp_282[0] = 0;
tmp_282[1] = 2;
tmp_282[2] = 0;
f__TC__cnpool__compl__l3__list(ps__domain, f__gen__compl3__by__domain(ps__domain, 3, f__gen__compl3__by__domain_mis_defval), tmp_282, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval);
}
current_location.update_lineno(2382);
/* HNBGW_Tests.ttcn, line 2382 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_no_allow_attach_round_robin was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__mscpool__no__allow__attach__valid__nri(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2387, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_no_allow_attach_valid_nri");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_no_allow_attach_valid_nri", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2389);
/* HNBGW_Tests.ttcn, line 2389 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 3, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2390);
/* HNBGW_Tests.ttcn, line 2390 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2392);
/* HNBGW_Tests.ttcn, line 2392 */
BOOLEAN ps__domain(FALSE);
current_location.update_lineno(2395);
/* HNBGW_Tests.ttcn, line 2395 */
{
BooleanList tmp_283;
tmp_283.set_size(3);
tmp_283[0] = TRUE;
tmp_283[1] = FALSE;
tmp_283[2] = TRUE;
f__vty__cnlink__allow__attach(test__CT_component_HNBGWVTY, ps__domain, tmp_283);
}
current_location.update_lineno(2399);
/* HNBGW_Tests.ttcn, line 2399 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2401);
/* HNBGW_Tests.ttcn, line 2401 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2403);
/* HNBGW_Tests.ttcn, line 2403 */
ro__MobileIdentityLV mis;
mis.set_size(3);
mis[0] = L3__Templates::ts__MI__TMSI__NRI__LV(260, L3__Templates::ts__MI__TMSI__NRI__LV_nri__bitlen_defval).valueof();
mis[1] = L3__Templates::ts__MI__IMSI__LV(hs_7).valueof();
mis[2] = L3__Templates::ts__MI__IMSI__LV(hs_8).valueof();
current_location.update_lineno(2409);
/* HNBGW_Tests.ttcn, line 2409 */
ro__octetstring compl3(f__gen__compl3__by__domain(ps__domain, 3, ro__MobileIdentityLV_template(mis)));
current_location.update_lineno(2412);
/* HNBGW_Tests.ttcn, line 2412 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[0], 1, CHARSTRING_template(cs_64), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2415);
/* HNBGW_Tests.ttcn, line 2415 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[1], 0, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2416);
/* HNBGW_Tests.ttcn, line 2416 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[2], 2, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2418);
/* HNBGW_Tests.ttcn, line 2418 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_no_allow_attach_valid_nri was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__mscpool__sccp__n__pcstate__detaches__cnlink(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2428, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_sccp_n_pcstate_detaches_cnlink");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_sccp_n_pcstate_detaches_cnlink", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2429);
/* HNBGW_Tests.ttcn, line 2429 */
f__TC__cnpool__sccp__n__pcstate__detaches__cnlink(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_sccp_n_pcstate_detaches_cnlink was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__sgsnpool__sccp__n__pcstate__detaches__cnlink(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2431, TTCN_Location::LOCATION_TESTCASE, "TC_sgsnpool_sccp_n_pcstate_detaches_cnlink");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sgsnpool_sccp_n_pcstate_detaches_cnlink", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2432);
/* HNBGW_Tests.ttcn, line 2432 */
f__TC__cnpool__sccp__n__pcstate__detaches__cnlink(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sgsnpool_sccp_n_pcstate_detaches_cnlink was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__sccp__n__pcstate__detaches__cnlink(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2434, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_sccp_n_pcstate_detaches_cnlink");
current_location.update_lineno(2437);
/* HNBGW_Tests.ttcn, line 2437 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 2, 2, f__init_start__hnb_defval);
current_location.update_lineno(2438);
/* HNBGW_Tests.ttcn, line 2438 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2442);
/* HNBGW_Tests.ttcn, line 2442 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2444);
/* HNBGW_Tests.ttcn, line 2444 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2446);
/* HNBGW_Tests.ttcn, line 2446 */
ro__octetstring compl3(f__gen__compl3__by__domain(ps__domain, 3, f__gen__compl3__by__domain_mis_defval));
current_location.update_lineno(2448);
/* HNBGW_Tests.ttcn, line 2448 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[0], 0, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2449);
/* HNBGW_Tests.ttcn, line 2449 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[1], 1, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2451);
/* HNBGW_Tests.ttcn, line 2451 */
Osmocom__VTY__Functions::f__logp(test__CT_component_HNBGWVTY, cs_72);
current_location.update_lineno(2452);
/* HNBGW_Tests.ttcn, line 2452 */
f__cn__idx__disconnect(f__cn__idx(ps__domain, 0));
current_location.update_lineno(2456);
/* HNBGW_Tests.ttcn, line 2456 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[2], 1, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2458);
/* HNBGW_Tests.ttcn, line 2458 */
f__shutdown__helper();
}

void start_f__TC__cnpool__sccp__n__pcstate__detaches__cnlink(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_sccp_n_pcstate_detaches_cnlink(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_sccp_n_pcstate_detaches_cnlink", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__sccp__n__pcstate__attaches__cnlink(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2463, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_sccp_n_pcstate_attaches_cnlink");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_sccp_n_pcstate_attaches_cnlink", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2464);
/* HNBGW_Tests.ttcn, line 2464 */
f__TC__cnpool__sccp__n__pcstate__attaches__cnlink(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_sccp_n_pcstate_attaches_cnlink was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__sgsnpool__sccp__n__pcstate__attaches__cnlink(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2466, TTCN_Location::LOCATION_TESTCASE, "TC_sgsnpool_sccp_n_pcstate_attaches_cnlink");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sgsnpool_sccp_n_pcstate_attaches_cnlink", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2467);
/* HNBGW_Tests.ttcn, line 2467 */
f__TC__cnpool__sccp__n__pcstate__attaches__cnlink(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sgsnpool_sccp_n_pcstate_attaches_cnlink was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__sccp__n__pcstate__attaches__cnlink(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2469, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_sccp_n_pcstate_attaches_cnlink");
current_location.update_lineno(2471);
/* HNBGW_Tests.ttcn, line 2471 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 1, 1, f__init_start__hnb_defval);
current_location.update_lineno(2472);
/* HNBGW_Tests.ttcn, line 2472 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2476);
/* HNBGW_Tests.ttcn, line 2476 */
f__vty__set__roundrobin__next(test__CT_component_HNBGWVTY, ps__domain, 0);
current_location.update_lineno(2478);
/* HNBGW_Tests.ttcn, line 2478 */
ro__octetstring compl3(f__gen__compl3__by__domain(ps__domain, 3, f__gen__compl3__by__domain_mis_defval));
current_location.update_lineno(2480);
/* HNBGW_Tests.ttcn, line 2480 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2483);
/* HNBGW_Tests.ttcn, line 2483 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[0], 0, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2484);
/* HNBGW_Tests.ttcn, line 2484 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[1], 0, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2486);
/* HNBGW_Tests.ttcn, line 2486 */
Osmocom__VTY__Functions::f__logp(test__CT_component_HNBGWVTY, cs_73);
current_location.update_lineno(2487);
/* HNBGW_Tests.ttcn, line 2487 */
f__cn__nr__init(ps__domain, 1);
current_location.update_lineno(2488);
/* HNBGW_Tests.ttcn, line 2488 */
{
BooleanList tmp_284;
tmp_284.set_size(2);
tmp_284[0] = TRUE;
tmp_284[1] = TRUE;
f__vty__cnlink__allow__attach(test__CT_component_HNBGWVTY, ps__domain, tmp_284);
}
current_location.update_lineno(2489);
/* HNBGW_Tests.ttcn, line 2489 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2492);
/* HNBGW_Tests.ttcn, line 2492 */
f__TC__cnpool__compl__l3(ps__domain, const_cast< const ro__octetstring&>(compl3)[2], 1, CHARSTRING_template(cs_63), f__TC__cnpool__compl__l3_expect__compl__l3__success_defval);
current_location.update_lineno(2494);
/* HNBGW_Tests.ttcn, line 2494 */
f__shutdown__helper();
}

void start_f__TC__cnpool__sccp__n__pcstate__attaches__cnlink(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_sccp_n_pcstate_attaches_cnlink(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_sccp_n_pcstate_attaches_cnlink", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

void f__vty__add__sccp__addr(TELNETasp__PortType::TELNETasp__PT& pt, const CHARSTRING& addr__name, const CHARSTRING& pc, const INTEGER& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2497, TTCN_Location::LOCATION_FUNCTION, "f_vty_add_sccp_addr");
current_location.update_lineno(2499);
/* HNBGW_Tests.ttcn, line 2499 */
Osmocom__VTY__Functions::f__vty__enter__config(pt);
current_location.update_lineno(2500);
/* HNBGW_Tests.ttcn, line 2500 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_9, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(2501);
/* HNBGW_Tests.ttcn, line 2501 */
Osmocom__VTY__Functions::f__vty__transceive(pt, (cs_74 + addr__name), Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(2502);
/* HNBGW_Tests.ttcn, line 2502 */
Osmocom__VTY__Functions::f__vty__transceive(pt, (cs_75 + pc), Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(2503);
/* HNBGW_Tests.ttcn, line 2503 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_44, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

void f__vty__set__cnlink__addr(TELNETasp__PortType::TELNETasp__PT& pt, const CHARSTRING& cnlink__and__nr, const CHARSTRING& addr__name)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2506, TTCN_Location::LOCATION_FUNCTION, "f_vty_set_cnlink_addr");
current_location.update_lineno(2508);
/* HNBGW_Tests.ttcn, line 2508 */
Osmocom__VTY__Functions::f__vty__enter__config(pt);
current_location.update_lineno(2509);
/* HNBGW_Tests.ttcn, line 2509 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cnlink__and__nr, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(2510);
/* HNBGW_Tests.ttcn, line 2510 */
Osmocom__VTY__Functions::f__vty__transceive(pt, (cs_76 + addr__name), Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(2511);
/* HNBGW_Tests.ttcn, line 2511 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_44, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

void f__vty__apply__sccp(TELNETasp__PortType::TELNETasp__PT& pt)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2514, TTCN_Location::LOCATION_FUNCTION, "f_vty_apply_sccp");
current_location.update_lineno(2516);
/* HNBGW_Tests.ttcn, line 2516 */
Osmocom__VTY__Functions::f__vty__enter__config(pt);
current_location.update_lineno(2517);
/* HNBGW_Tests.ttcn, line 2517 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_77, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
current_location.update_lineno(2518);
/* HNBGW_Tests.ttcn, line 2518 */
Osmocom__VTY__Functions::f__vty__transceive(pt, cs_44, Osmocom__VTY__Functions::f__vty__transceive_strict_defval);
}

void f__tc__apply__sccp(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2522, TTCN_Location::LOCATION_FUNCTION, "f_tc_apply_sccp");
current_location.update_lineno(2524);
/* HNBGW_Tests.ttcn, line 2524 */
ConnHdlr::f__perform__compl__l3(f__gen__compl3__by__domain(const_cast< const ConnHdlr::TestHdlrParams&>(ConnHdlr::ConnHdlr_component_g__pars).ps__domain(), 1, f__gen__compl3__by__domain_mis_defval)[0], ConnHdlr::f__perform__compl__l3_do__clear_defval, ConnHdlr::f__perform__compl__l3_expect__success_defval);
current_location.update_lineno(2526);
/* HNBGW_Tests.ttcn, line 2526 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2527);
/* HNBGW_Tests.ttcn, line 2527 */
Osmocom__VTY__Functions::f__logp(ConnHdlr::ConnHdlr_component_HNBGWVTY, cs_78);
current_location.update_lineno(2529);
/* HNBGW_Tests.ttcn, line 2529 */
f__vty__add__sccp__addr(ConnHdlr::ConnHdlr_component_HNBGWVTY, cs_79, cs_80, f__vty__add__sccp__addr_cs7__nr_defval);
current_location.update_lineno(2530);
/* HNBGW_Tests.ttcn, line 2530 */
f__vty__set__cnlink__addr(ConnHdlr::ConnHdlr_component_HNBGWVTY, cs_81, cs_79);
current_location.update_lineno(2533);
/* HNBGW_Tests.ttcn, line 2533 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2534);
/* HNBGW_Tests.ttcn, line 2534 */
ConnHdlr::f__iuh2iu(RANAP__Templates::ts__RANAP__DirectTransfer(OCTETSTRING_template(Osmocom__Types::f__rnd__octstring(10)), RANAP__Templates::ts__RANAP__DirectTransfer_sapi_defval, RANAP__Templates::ts__RANAP__DirectTransfer_ies_defval, RANAP__Templates::ts__RANAP__DirectTransfer_exts_defval), ConnHdlr::f__iuh2iu_exp__rx_defval);
current_location.update_lineno(2535);
/* HNBGW_Tests.ttcn, line 2535 */
ConnHdlr::f__iu2iuh(RANAP__Templates::ts__RANAP__DirectTransfer(OCTETSTRING_template(Osmocom__Types::f__rnd__octstring(10)), RANAP__Templates::ts__RANAP__DirectTransfer_sapi_defval, RANAP__Templates::ts__RANAP__DirectTransfer_ies_defval, RANAP__Templates::ts__RANAP__DirectTransfer_exts_defval), ConnHdlr::f__iu2iuh_exp__rx_defval);
current_location.update_lineno(2537);
/* HNBGW_Tests.ttcn, line 2537 */
Osmocom__VTY__Functions::f__logp(ConnHdlr::ConnHdlr_component_HNBGWVTY, cs_82);
current_location.update_lineno(2538);
/* HNBGW_Tests.ttcn, line 2538 */
f__vty__apply__sccp(ConnHdlr::ConnHdlr_component_HNBGWVTY);
current_location.update_lineno(2541);
/* HNBGW_Tests.ttcn, line 2541 */
{
tmp_285:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = RUA__Emulation::RUA__ConnHdlr_component_RUA.receive(RUA__Emulation::RUA__Disc__Ind_template(ANY_VALUE), NULL, any_compref, NULL, NULL, NULL);
if (alt_flag == ALT_YES) break;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_285;
}
current_location.update_lineno(2541);
/* HNBGW_Tests.ttcn, line 2541 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone receive statement failed in file HNBGW_Tests.ttcn, line 2541.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2542);
/* HNBGW_Tests.ttcn, line 2542 */
{
tmp_286:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.receive(RAN__Emulation::tr__MSC__CONN__PRIM__DISC__IND, NULL, any_compref, NULL, NULL, NULL);
if (alt_flag == ALT_YES) break;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_286;
}
current_location.update_lineno(2542);
/* HNBGW_Tests.ttcn, line 2542 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone receive statement failed in file HNBGW_Tests.ttcn, line 2542.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2547);
/* HNBGW_Tests.ttcn, line 2547 */
Osmocom__Types::f__sleep(1.0);
}

void start_f__tc__apply__sccp(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_apply_sccp(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_apply_sccp", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__apply__sccp(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2549, TTCN_Location::LOCATION_TESTCASE, "TC_apply_sccp");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_apply_sccp", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2551);
/* HNBGW_Tests.ttcn, line 2551 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2552);
/* HNBGW_Tests.ttcn, line 2552 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2554);
/* HNBGW_Tests.ttcn, line 2554 */
COMPONENT vc__conn;
current_location.update_lineno(2555);
/* HNBGW_Tests.ttcn, line 2555 */
ConnHdlr::TestHdlrParams_template pars(f__TestHdlrParams(0, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval));
current_location.update_lineno(2556);
/* HNBGW_Tests.ttcn, line 2556 */
vc__conn = f__start__handler__with__pars(&f__tc__apply__sccp, pars);
current_location.update_lineno(2557);
/* HNBGW_Tests.ttcn, line 2557 */
{
tmp_288:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_288;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_288;
}
current_location.update_lineno(2557);
/* HNBGW_Tests.ttcn, line 2557 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 2557.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2559);
/* HNBGW_Tests.ttcn, line 2559 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_apply_sccp was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__tc__second__rab__assignment(const CHARSTRING& )
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2565, TTCN_Location::LOCATION_FUNCTION, "f_tc_second_rab_assignment");
current_location.update_lineno(2566);
/* HNBGW_Tests.ttcn, line 2566 */
MGCP__Types::MgcpCommand mgcp__cmd;
current_location.update_lineno(2567);
/* HNBGW_Tests.ttcn, line 2567 */
RANAP__PDU__Descriptions::RANAP__PDU tx;
current_location.update_lineno(2568);
/* HNBGW_Tests.ttcn, line 2568 */
TIMER T("T", 5.0);
current_location.update_lineno(2570);
/* HNBGW_Tests.ttcn, line 2570 */
tx = ConnHdlr::f__build__initial__ue(ConnHdlr::ConnHdlr_component_g__pars);
current_location.update_lineno(2571);
/* HNBGW_Tests.ttcn, line 2571 */
ConnHdlr::f__iuh2iu__connect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx), ConnHdlr::f__iuh2iu__connect_exp__rx_defval);
current_location.update_lineno(2573);
/* HNBGW_Tests.ttcn, line 2573 */
ConnHdlr::f__create__rab__cs();
current_location.update_lineno(2577);
/* HNBGW_Tests.ttcn, line 2577 */
RANAP__PDU__Contents::_root_RANAP__Containers_ProtocolIE__ContainerPairList_RANAP__PDU__Contents_inst1_template rab__sml;
current_location.update_lineno(2578);
/* HNBGW_Tests.ttcn, line 2578 */
rab__sml = RANAP__Templates::ts__RAB__SML2(RANAP__Templates::t__RAB__id(23), RANAP__Templates::ts__RabParams, RANAP__PDU__Contents::UserPlaneInformation_template(OMIT_VALUE), RANAP__PDU__Contents::TransportLayerInformation_template(OMIT_VALUE));
current_location.update_lineno(2582);
/* HNBGW_Tests.ttcn, line 2582 */
{
RANAP__PDU__Contents::_root_RANAP__Containers_ProtocolIE__ContainerPairList_RANAP__PDU__Contents_inst1_template tmp_292;
tmp_292 = rab__sml;
tmp_292.check_restriction(TR_OMIT);
tx = RANAP__Templates::ts__RANAP__RabAssReq(tmp_292, RANAP__Templates::ts__RANAP__RabAssReq_rab__rl_defval, RANAP__Templates::ts__RANAP__RabAssReq_exts_defval).valueof();
}
current_location.update_lineno(2583);
/* HNBGW_Tests.ttcn, line 2583 */
RAN__Emulation::RAN__ConnHdlr_component_RAN__CONN.send(tx, FALSE, NULL);
current_location.update_lineno(2584);
/* HNBGW_Tests.ttcn, line 2584 */
T.start();
current_location.update_lineno(2587);
/* HNBGW_Tests.ttcn, line 2587 */
ConnHdlr::f__rua__expect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx));
current_location.update_lineno(2593);
/* HNBGW_Tests.ttcn, line 2593 */
RANAP__PDU__Contents::_root_RANAP__Containers_ProtocolIE__ContainerList_RANAP__PDU__Contents_inst19_template rab__smdl;
current_location.update_lineno(2594);
/* HNBGW_Tests.ttcn, line 2594 */
rab__smdl = RANAP__Templates::ts__RAB__SMdL__no__tla(RANAP__Templates::t__RAB__id(23));
current_location.update_lineno(2595);
/* HNBGW_Tests.ttcn, line 2595 */
{
RANAP__PDU__Contents::_root_RANAP__Containers_ProtocolIE__ContainerList_RANAP__PDU__Contents_inst19_template tmp_295;
tmp_295 = rab__smdl;
tmp_295.check_restriction(TR_OMIT);
tx = RANAP__Templates::ts__RANAP__RabAssResp(tmp_295, RANAP__Templates::ts__RANAP__RabAssResp_rab__rl_defval, RANAP__Templates::ts__RANAP__RabAssResp_rab__fl_defval, RANAP__Templates::ts__RANAP__RabAssResp_exts_defval).valueof();
}
current_location.update_lineno(2596);
/* HNBGW_Tests.ttcn, line 2596 */
RUA__Emulation::RUA__ConnHdlr_component_RUA.send(tx, FALSE, NULL);
current_location.update_lineno(2597);
/* HNBGW_Tests.ttcn, line 2597 */
ConnHdlr::f__bssap__expect(RANAP__PDU__Descriptions::RANAP__PDU_template(tx));
current_location.update_lineno(2600);
/* HNBGW_Tests.ttcn, line 2600 */
ConnHdlr::f__cn__iu__release__procedure(TRUE, ConnHdlr::f__cn__iu__release__procedure_pfcp__teardown_defval);
}

void start_f__tc__second__rab__assignment(const COMPONENT& component_reference, const CHARSTRING& id)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_second_rab_assignment(");
id.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_tc_second_rab_assignment", text_buf);
id.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__second__rab__assignment(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2603, TTCN_Location::LOCATION_TESTCASE, "TC_second_rab_assignment");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_second_rab_assignment", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2604);
/* HNBGW_Tests.ttcn, line 2604 */
COMPONENT vc__conn;
current_location.update_lineno(2605);
/* HNBGW_Tests.ttcn, line 2605 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(2606);
/* HNBGW_Tests.ttcn, line 2606 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2608);
/* HNBGW_Tests.ttcn, line 2608 */
vc__conn = f__start__handler__with__pars(&f__tc__second__rab__assignment, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(3, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(2609);
/* HNBGW_Tests.ttcn, line 2609 */
{
tmp_298:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_298;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_298;
}
current_location.update_lineno(2609);
/* HNBGW_Tests.ttcn, line 2609 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 2609.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2611);
/* HNBGW_Tests.ttcn, line 2611 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_second_rab_assignment was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void f__TC__cnpool__L3Compl__no__cn(const BOOLEAN& ps__domain)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2615, TTCN_Location::LOCATION_FUNCTION, "f_TC_cnpool_L3Compl_no_cn");
current_location.update_lineno(2620);
/* HNBGW_Tests.ttcn, line 2620 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, f__init_nr__msc_defval, f__init_nr__sgsn_defval, f__init_start__hnb_defval);
current_location.update_lineno(2621);
/* HNBGW_Tests.ttcn, line 2621 */
{
BooleanList tmp_299;
tmp_299.set_size(1);
tmp_299[0] = FALSE;
f__vty__cnlink__allow__attach(test__CT_component_HNBGWVTY, ps__domain, tmp_299);
}
current_location.update_lineno(2623);
/* HNBGW_Tests.ttcn, line 2623 */
f__ctrs__cn__init(ps__domain, f__ctrs__cn__init_cn__count_defval, f__ctrs__cn__init_counternames_defval);
current_location.update_lineno(2625);
/* HNBGW_Tests.ttcn, line 2625 */
ro__octetstring compl3(f__gen__compl3__by__domain(ps__domain, 4, f__gen__compl3__by__domain_mis_defval));
current_location.update_lineno(2626);
/* HNBGW_Tests.ttcn, line 2626 */
{
Osmocom__Types::ro__integer tmp_300;
tmp_300.set_size(4);
tmp_300[0] = 0;
tmp_300[1] = 0;
tmp_300[2] = 0;
tmp_300[3] = 0;
f__TC__cnpool__compl__l3__list(ps__domain, compl3, tmp_300, CHARSTRING_template(OMIT_VALUE), FALSE);
}
current_location.update_lineno(2629);
/* HNBGW_Tests.ttcn, line 2629 */
f__shutdown__helper();
}

void start_f__TC__cnpool__L3Compl__no__cn(const COMPONENT& component_reference, const BOOLEAN& ps__domain)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Compl_no_cn(");
ps__domain.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_cnpool_L3Compl_no_cn", text_buf);
ps__domain.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__mscpool__L3Compl__no__cn(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2631, TTCN_Location::LOCATION_TESTCASE, "TC_mscpool_L3Compl_no_cn");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_mscpool_L3Compl_no_cn", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2632);
/* HNBGW_Tests.ttcn, line 2632 */
f__TC__cnpool__L3Compl__no__cn(FALSE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_mscpool_L3Compl_no_cn was stopped.");
}
return TTCN_Runtime::end_testcase();
}

verdicttype testcase_TC__sgsnpool__L3Compl__no__cn(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2634, TTCN_Location::LOCATION_TESTCASE, "TC_sgsnpool_L3Compl_no_cn");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_sgsnpool_L3Compl_no_cn", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2635);
/* HNBGW_Tests.ttcn, line 2635 */
f__TC__cnpool__L3Compl__no__cn(TRUE);
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_sgsnpool_L3Compl_no_cn was stopped.");
}
return TTCN_Runtime::end_testcase();
}

RANAP__PDU__Descriptions::RANAP__PDU_template f__TC__stat__stp__sctp__disconnected__UnitdataCallback(const RANAP__PDU__Descriptions::RANAP__PDU& ranap)
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2644, TTCN_Location::LOCATION_FUNCTION, "f_TC_stat_stp_sctp_disconnected_UnitdataCallback");
current_location.update_lineno(2645);
/* HNBGW_Tests.ttcn, line 2645 */
if (RANAP__Templates::tr__RANAP__Reset(RANAP__Templates::tr__RANAP__Reset_cause_defval, RANAP__Templates::tr__RANAP__Reset_dom_defval, RANAP__Templates::tr__RANAP__Reset_exts_defval).match(ranap)) {
current_location.update_lineno(2646);
/* HNBGW_Tests.ttcn, line 2646 */
try {
TTCN_Logger::begin_event(TTCN_USER);
TTCN_Logger::log_event_str("Answering RESET with RESET-ACK: ");
ranap.log();
TTCN_Logger::end_event();
} catch (...) {
TTCN_Logger::finish_event();
throw;
}
current_location.update_lineno(2647);
/* HNBGW_Tests.ttcn, line 2647 */
return RANAP__PDU__Descriptions::RANAP__PDU_template(RANAP__Templates::f__ts__RANAP__ResetAck(RANAP__IEs::CN__DomainIndicator_template(const_cast< const RANAP__PDU__Descriptions::RANAP__PDU&>(ranap).initiatingMessage().value__().reset().protocolIEs()[1].value__().cN__DomainIndicator()), RANAP__Templates::f__ts__RANAP__ResetAck_grnc__id_defval, RANAP__Templates::f__ts__RANAP__ResetAck_exts_defval).valueof());
}
current_location.update_lineno(2649);
/* HNBGW_Tests.ttcn, line 2649 */
return RANAP__PDU__Descriptions::RANAP__PDU_template(OMIT_VALUE);
}

void start_f__TC__stat__stp__sctp__disconnected__UnitdataCallback(const COMPONENT& component_reference, const RANAP__PDU__Descriptions::RANAP__PDU& ranap)
{
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_stat_stp_sctp_disconnected_UnitdataCallback(");
ranap.log();
TTCN_Logger::log_event_str(") on component ");
component_reference.log();
TTCN_Logger::log_char('.');
TTCN_Logger::end_event();
Text_Buf text_buf;
TTCN_Runtime::prepare_start_component(component_reference, "HNBGW_Tests", "f_TC_stat_stp_sctp_disconnected_UnitdataCallback", text_buf);
ranap.encode_text(text_buf);
TTCN_Runtime::send_start_component(text_buf);
}

verdicttype testcase_TC__stat__stp__sctp__disconnected(boolean has_timer, double timer_value)
{
TTCN_Runtime::check_begin_testcase(has_timer, timer_value);
TTCN_Location current_location("HNBGW_Tests.ttcn", 2651, TTCN_Location::LOCATION_TESTCASE, "TC_stat_stp_sctp_disconnected");
try {
TTCN_Runtime::begin_testcase("HNBGW_Tests", "TC_stat_stp_sctp_disconnected", "HNBGW_Tests", "test_CT", "HNBGW_Tests", "test_CT", has_timer, timer_value);
current_location.update_lineno(2653);
/* HNBGW_Tests.ttcn, line 2653 */
COMPONENT vc__conn;
current_location.update_lineno(2655);
/* HNBGW_Tests.ttcn, line 2655 */
test__CT_component_g__num__hnbs = 1;
current_location.update_lineno(2656);
/* HNBGW_Tests.ttcn, line 2656 */
test__CT_component_g__statd__timeout = 1.5e1;
current_location.update_lineno(2657);
/* HNBGW_Tests.ttcn, line 2657 */
test__CT_component_g__ran__ops.ranap__unitdata__cb() = &f__TC__stat__stp__sctp__disconnected__UnitdataCallback;
current_location.update_lineno(2658);
/* HNBGW_Tests.ttcn, line 2658 */
f__init(f__init_id_defval, f__init_guard__timeout_defval, 1, 1, f__init_start__hnb_defval);
current_location.update_lineno(2659);
/* HNBGW_Tests.ttcn, line 2659 */
f__init__vty__stp();
current_location.update_lineno(2660);
/* HNBGW_Tests.ttcn, line 2660 */
Osmocom__Types::f__sleep(1.0);
current_location.update_lineno(2662);
/* HNBGW_Tests.ttcn, line 2662 */
TTCN_Runtime::connect_port(self, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
current_location.update_lineno(2663);
/* HNBGW_Tests.ttcn, line 2663 */
StatsD__Checker::f__statsd__reset();
current_location.update_lineno(2666);
/* HNBGW_Tests.ttcn, line 2666 */
CHARSTRING msc0__prefix((mp__statsd__prefix + cs_83));
current_location.update_lineno(2667);
/* HNBGW_Tests.ttcn, line 2667 */
CHARSTRING sgsn0__prefix((mp__statsd__prefix + cs_84));
current_location.update_lineno(2668);
/* HNBGW_Tests.ttcn, line 2668 */
StatsD__Checker::StatsDExpects expect__connected;
expect__connected.set_size(2);
{
StatsD__Checker::StatsDExpect& tmp_304 = expect__connected[0];
tmp_304.name() = (msc0__prefix + cs_85);
tmp_304.mtype() = cs_12;
tmp_304.min() = 1;
tmp_304.max() = 1;
}
{
StatsD__Checker::StatsDExpect& tmp_305 = expect__connected[1];
tmp_305.name() = (sgsn0__prefix + cs_85);
tmp_305.mtype() = cs_12;
tmp_305.min() = 1;
tmp_305.max() = 1;
}
current_location.update_lineno(2672);
/* HNBGW_Tests.ttcn, line 2672 */
StatsD__Checker::StatsDExpects expect__disconnected;
expect__disconnected.set_size(2);
{
StatsD__Checker::StatsDExpect& tmp_306 = expect__disconnected[0];
tmp_306.name() = (msc0__prefix + cs_85);
tmp_306.mtype() = cs_12;
tmp_306.min() = 0;
tmp_306.max() = 0;
}
{
StatsD__Checker::StatsDExpect& tmp_307 = expect__disconnected[1];
tmp_307.name() = (sgsn0__prefix + cs_85);
tmp_307.mtype() = cs_12;
tmp_307.min() = 0;
tmp_307.max() = 0;
}
current_location.update_lineno(2676);
/* HNBGW_Tests.ttcn, line 2676 */
StatsD__Checker::f__statsd__expect(expect__connected, StatsD__Checker::f__statsd__expect_wait__converge_defval);
current_location.update_lineno(2677);
/* HNBGW_Tests.ttcn, line 2677 */
TTCN_Runtime::disconnect_port(self, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
current_location.update_lineno(2679);
/* HNBGW_Tests.ttcn, line 2679 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__assignment, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(3, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(2680);
/* HNBGW_Tests.ttcn, line 2680 */
{
tmp_309:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_309;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_309;
}
current_location.update_lineno(2680);
/* HNBGW_Tests.ttcn, line 2680 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 2680.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2682);
/* HNBGW_Tests.ttcn, line 2682 */
Osmocom__VTY__Functions::f__logp(test__CT_component_HNBGWVTY, cs_86);
current_location.update_lineno(2683);
/* HNBGW_Tests.ttcn, line 2683 */
f__vty__stp__hnbgw__asp__cmd(cs_87);
current_location.update_lineno(2685);
/* HNBGW_Tests.ttcn, line 2685 */
TTCN_Runtime::connect_port(self, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
current_location.update_lineno(2686);
/* HNBGW_Tests.ttcn, line 2686 */
StatsD__Checker::f__statsd__expect(expect__disconnected, TRUE);
current_location.update_lineno(2687);
/* HNBGW_Tests.ttcn, line 2687 */
TTCN_Runtime::disconnect_port(self, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
current_location.update_lineno(2689);
/* HNBGW_Tests.ttcn, line 2689 */
Osmocom__VTY__Functions::f__logp(test__CT_component_HNBGWVTY, cs_88);
current_location.update_lineno(2690);
/* HNBGW_Tests.ttcn, line 2690 */
f__vty__stp__hnbgw__asp__cmd(cs_89);
current_location.update_lineno(2692);
/* HNBGW_Tests.ttcn, line 2692 */
TTCN_Runtime::connect_port(self, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
current_location.update_lineno(2693);
/* HNBGW_Tests.ttcn, line 2693 */
StatsD__Checker::f__statsd__expect(expect__connected, TRUE);
current_location.update_lineno(2694);
/* HNBGW_Tests.ttcn, line 2694 */
TTCN_Runtime::disconnect_port(self, StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.get_name(), test__CT_component_vc__STATSD, StatsD__Checker::StatsD__Checker__CT_component_STATSD__PROC.get_name());
current_location.update_lineno(2696);
/* HNBGW_Tests.ttcn, line 2696 */
vc__conn = f__start__handler__with__pars(&f__tc__rab__assignment, ConnHdlr::TestHdlrParams_template(f__TestHdlrParams(4, f__TestHdlrParams_ps__domain_defval, f__TestHdlrParams_expect__separate__sccp__cr_defval, f__TestHdlrParams_tx__sccp__cr__data__len_defval, f__TestHdlrParams_expect__compl__l3__success_defval, f__TestHdlrParams_cn__nr_defval, f__TestHdlrParams_rab__rel__cause_defval)));
current_location.update_lineno(2697);
/* HNBGW_Tests.ttcn, line 2697 */
{
tmp_311:
alt_status alt_flag = ALT_UNCHECKED, default_flag = ALT_UNCHECKED;
boolean first_run = TRUE;
TTCN_Snapshot::take_new(FALSE);
for ( ; ; ) {
if (alt_flag != ALT_NO) {
alt_flag = vc__conn.done(NULL, NULL);
if (alt_flag == ALT_YES) break;
else if (alt_flag == ALT_REPEAT) goto tmp_311;
}
if (default_flag != ALT_NO) {
default_flag = TTCN_Default::try_altsteps(first_run);
if (default_flag == ALT_YES || default_flag == ALT_BREAK) break;
else if (default_flag == ALT_REPEAT) goto tmp_311;
}
current_location.update_lineno(2697);
/* HNBGW_Tests.ttcn, line 2697 */
if (alt_flag == ALT_NO && default_flag == ALT_NO) TTCN_error("Stand-alone done statement failed in file HNBGW_Tests.ttcn, line 2697.");
TTCN_Snapshot::take_new(TRUE);
first_run = FALSE;
}
}
current_location.update_lineno(2699);
/* HNBGW_Tests.ttcn, line 2699 */
f__shutdown__helper();
} catch (const TC_Error& tc_error) {
} catch (const TC_End& tc_end) {
TTCN_Logger::log_str(TTCN_FUNCTION, "Test case TC_stat_stp_sctp_disconnected was stopped.");
}
return TTCN_Runtime::end_testcase();
}

void module_control_part()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 2702, TTCN_Location::LOCATION_CONTROLPART, "HNBGW_Tests");
TTCN_Runtime::begin_controlpart("HNBGW_Tests");
TTCN_ControlPartEnder ender_("HNBGW_Tests");
current_location.update_lineno(2703);
/* HNBGW_Tests.ttcn, line 2703 */
testcase_TC__hnb__register(FALSE, 0.0);
current_location.update_lineno(2704);
/* HNBGW_Tests.ttcn, line 2704 */
testcase_TC__hnb__register__duplicate(FALSE, 0.0);
current_location.update_lineno(2705);
/* HNBGW_Tests.ttcn, line 2705 */
testcase_TC__hnb__register__duplicate__reuse__sctp__assoc(FALSE, 0.0);
current_location.update_lineno(2706);
/* HNBGW_Tests.ttcn, line 2706 */
testcase_TC__hnb__disconnected__timeout(FALSE, 0.0);
current_location.update_lineno(2707);
/* HNBGW_Tests.ttcn, line 2707 */
testcase_TC__ue__register(FALSE, 0.0);
current_location.update_lineno(2708);
/* HNBGW_Tests.ttcn, line 2708 */
testcase_TC__ue__register__tmsi__lai(FALSE, 0.0);
current_location.update_lineno(2709);
/* HNBGW_Tests.ttcn, line 2709 */
testcase_TC__ue__register__before__hnb__register(FALSE, 0.0);
current_location.update_lineno(2710);
/* HNBGW_Tests.ttcn, line 2710 */
testcase_TC__ranap__cs__initial__ue(FALSE, 0.0);
current_location.update_lineno(2711);
/* HNBGW_Tests.ttcn, line 2711 */
testcase_TC__ranap__ps__initial__ue(FALSE, 0.0);
current_location.update_lineno(2712);
/* HNBGW_Tests.ttcn, line 2712 */
testcase_TC__ranap__cs__initial__ue__empty__cr(FALSE, 0.0);
current_location.update_lineno(2713);
/* HNBGW_Tests.ttcn, line 2713 */
testcase_TC__ranap__ps__initial__ue__empty__cr(FALSE, 0.0);
current_location.update_lineno(2714);
/* HNBGW_Tests.ttcn, line 2714 */
testcase_TC__ranap__cs__bidir(FALSE, 0.0);
current_location.update_lineno(2715);
/* HNBGW_Tests.ttcn, line 2715 */
testcase_TC__ranap__ps__bidir(FALSE, 0.0);
current_location.update_lineno(2716);
/* HNBGW_Tests.ttcn, line 2716 */
testcase_TC__sccp__cr__limit(FALSE, 0.0);
current_location.update_lineno(2717);
/* HNBGW_Tests.ttcn, line 2717 */
testcase_TC__rab__assignment(FALSE, 0.0);
current_location.update_lineno(2718);
/* HNBGW_Tests.ttcn, line 2718 */
testcase_TC__rab__assignment__concurrent(FALSE, 0.0);
current_location.update_lineno(2719);
/* HNBGW_Tests.ttcn, line 2719 */
testcase_TC__rab__release(FALSE, 0.0);
current_location.update_lineno(2720);
/* HNBGW_Tests.ttcn, line 2720 */
testcase_TC__rab__release__abnormal(FALSE, 0.0);
current_location.update_lineno(2721);
/* HNBGW_Tests.ttcn, line 2721 */
testcase_TC__rab__assign__fail(FALSE, 0.0);
current_location.update_lineno(2722);
/* HNBGW_Tests.ttcn, line 2722 */
testcase_TC__rab__assign__mgcp__to(FALSE, 0.0);
current_location.update_lineno(2723);
/* HNBGW_Tests.ttcn, line 2723 */
testcase_TC__rab__assign__mgw__iuup__addr__chg(FALSE, 0.0);
current_location.update_lineno(2724);
/* HNBGW_Tests.ttcn, line 2724 */
testcase_TC__ranap__cs__mo__disconnect(FALSE, 0.0);
current_location.update_lineno(2725);
/* HNBGW_Tests.ttcn, line 2725 */
testcase_TC__ranap__ps__mo__disconnect(FALSE, 0.0);
current_location.update_lineno(2726);
/* HNBGW_Tests.ttcn, line 2726 */
testcase_TC__ranap__cs__creq__cref(FALSE, 0.0);
current_location.update_lineno(2727);
/* HNBGW_Tests.ttcn, line 2727 */
testcase_TC__ranap__ps__creq__cref(FALSE, 0.0);
current_location.update_lineno(2728);
/* HNBGW_Tests.ttcn, line 2728 */
testcase_TC__ps__rua__disconnect__during__sccp__cr__cc(FALSE, 0.0);
current_location.update_lineno(2729);
/* HNBGW_Tests.ttcn, line 2729 */
testcase_TC__cs__rua__disconnect__during__sccp__cr__cc(FALSE, 0.0);
current_location.update_lineno(2730);
/* HNBGW_Tests.ttcn, line 2730 */
testcase_TC__cs__iu__release__req__rua__disconnect(FALSE, 0.0);
current_location.update_lineno(2731);
/* HNBGW_Tests.ttcn, line 2731 */
testcase_TC__ps__iu__release__req__rua__disconnect(FALSE, 0.0);
current_location.update_lineno(2732);
/* HNBGW_Tests.ttcn, line 2732 */
testcase_TC__cs__rua__dt__during__sccp__wait__cc(FALSE, 0.0);
current_location.update_lineno(2733);
/* HNBGW_Tests.ttcn, line 2733 */
testcase_TC__ps__rua__dt__during__sccp__wait__cc(FALSE, 0.0);
current_location.update_lineno(2734);
/* HNBGW_Tests.ttcn, line 2734 */
testcase_TC__ps__rab__assignment(FALSE, 0.0);
current_location.update_lineno(2735);
/* HNBGW_Tests.ttcn, line 2735 */
testcase_TC__ps__rab__assignment__concurrent(FALSE, 0.0);
current_location.update_lineno(2736);
/* HNBGW_Tests.ttcn, line 2736 */
testcase_TC__ps__rab__release(FALSE, 0.0);
current_location.update_lineno(2737);
/* HNBGW_Tests.ttcn, line 2737 */
testcase_TC__ps__rab__release__abnormal(FALSE, 0.0);
current_location.update_lineno(2739);
/* HNBGW_Tests.ttcn, line 2739 */
testcase_TC__mscpool__L3Compl__on__1__cnlink(FALSE, 0.0);
current_location.update_lineno(2740);
/* HNBGW_Tests.ttcn, line 2740 */
testcase_TC__mscpool__L3Complete__by__imsi__round__robin(FALSE, 0.0);
current_location.update_lineno(2741);
/* HNBGW_Tests.ttcn, line 2741 */
testcase_TC__mscpool__LU__by__tmsi__null__nri__0__round__robin(FALSE, 0.0);
current_location.update_lineno(2742);
/* HNBGW_Tests.ttcn, line 2742 */
testcase_TC__mscpool__LU__by__tmsi__null__nri__1__round__robin(FALSE, 0.0);
current_location.update_lineno(2743);
/* HNBGW_Tests.ttcn, line 2743 */
testcase_TC__mscpool__L3Complete__by__tmsi__unassigned__nri__round__robin(FALSE, 0.0);
current_location.update_lineno(2744);
/* HNBGW_Tests.ttcn, line 2744 */
testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin(FALSE, 0.0);
current_location.update_lineno(2745);
/* HNBGW_Tests.ttcn, line 2745 */
testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__1(FALSE, 0.0);
current_location.update_lineno(2746);
/* HNBGW_Tests.ttcn, line 2746 */
testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__2(FALSE, 0.0);
current_location.update_lineno(2747);
/* HNBGW_Tests.ttcn, line 2747 */
testcase_TC__mscpool__L3Compl__no__cn(FALSE, 0.0);
current_location.update_lineno(2748);
/* HNBGW_Tests.ttcn, line 2748 */
testcase_TC__mscpool__LU__by__tmsi__from__other__PLMN(FALSE, 0.0);
current_location.update_lineno(2749);
/* HNBGW_Tests.ttcn, line 2749 */
testcase_TC__mscpool__paging__imsi(FALSE, 0.0);
current_location.update_lineno(2750);
/* HNBGW_Tests.ttcn, line 2750 */
testcase_TC__mscpool__paging__tmsi(FALSE, 0.0);
current_location.update_lineno(2751);
/* HNBGW_Tests.ttcn, line 2751 */
testcase_TC__mscpool__paging__imsi__lai__registered(FALSE, 0.0);
current_location.update_lineno(2752);
/* HNBGW_Tests.ttcn, line 2752 */
testcase_TC__mscpool__paging__imsi__rai__registered(FALSE, 0.0);
current_location.update_lineno(2753);
/* HNBGW_Tests.ttcn, line 2753 */
testcase_TC__mscpool__no__allow__attach__round__robin(FALSE, 0.0);
current_location.update_lineno(2754);
/* HNBGW_Tests.ttcn, line 2754 */
testcase_TC__mscpool__no__allow__attach__valid__nri(FALSE, 0.0);
current_location.update_lineno(2755);
/* HNBGW_Tests.ttcn, line 2755 */
testcase_TC__mscpool__sccp__n__pcstate__detaches__cnlink(FALSE, 0.0);
current_location.update_lineno(2756);
/* HNBGW_Tests.ttcn, line 2756 */
testcase_TC__mscpool__sccp__n__pcstate__attaches__cnlink(FALSE, 0.0);
current_location.update_lineno(2758);
/* HNBGW_Tests.ttcn, line 2758 */
testcase_TC__sgsnpool__L3Compl__on__1__cnlink(FALSE, 0.0);
current_location.update_lineno(2759);
/* HNBGW_Tests.ttcn, line 2759 */
testcase_TC__sgsnpool__L3Complete__no__nri__round__robin(FALSE, 0.0);
current_location.update_lineno(2760);
/* HNBGW_Tests.ttcn, line 2760 */
testcase_TC__sgsnpool__L3Complete__valid__nri__1(FALSE, 0.0);
current_location.update_lineno(2761);
/* HNBGW_Tests.ttcn, line 2761 */
testcase_TC__sgsnpool__L3Complete__valid__nri__2(FALSE, 0.0);
current_location.update_lineno(2762);
/* HNBGW_Tests.ttcn, line 2762 */
testcase_TC__sgsnpool__L3Compl__no__cn(FALSE, 0.0);
current_location.update_lineno(2763);
/* HNBGW_Tests.ttcn, line 2763 */
testcase_TC__sgsnpool__nri__from__other__PLMN(FALSE, 0.0);
current_location.update_lineno(2764);
/* HNBGW_Tests.ttcn, line 2764 */
testcase_TC__sgsnpool__sccp__n__pcstate__detaches__cnlink(FALSE, 0.0);
current_location.update_lineno(2765);
/* HNBGW_Tests.ttcn, line 2765 */
testcase_TC__sgsnpool__sccp__n__pcstate__attaches__cnlink(FALSE, 0.0);
current_location.update_lineno(2767);
/* HNBGW_Tests.ttcn, line 2767 */
testcase_TC__second__rab__assignment(FALSE, 0.0);
current_location.update_lineno(2768);
/* HNBGW_Tests.ttcn, line 2768 */
testcase_TC__hnb__reregister__reuse__sctp__assoc(FALSE, 0.0);
current_location.update_lineno(2770);
/* HNBGW_Tests.ttcn, line 2770 */
testcase_TC__stat__stp__sctp__disconnected(FALSE, 0.0);
current_location.update_lineno(2773);
/* HNBGW_Tests.ttcn, line 2773 */
testcase_TC__apply__sccp(FALSE, 0.0);
}


/* Bodies of static functions */

void pre_init_module()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 0, TTCN_Location::LOCATION_UNKNOWN, "HNBGW_Tests");
ConnHdlr::module_object.pre_init_module();
current_location.update_lineno(80);
/* HNBGW_Tests.ttcn, line 80 */
const_NUM__MSC = 4;
current_location.update_lineno(81);
/* HNBGW_Tests.ttcn, line 81 */
const_NUM__SGSN = 4;
current_location.update_lineno(83);
/* HNBGW_Tests.ttcn, line 83 */
const_FIRST__MSC__IDX = 0;
current_location.update_lineno(84);
/* HNBGW_Tests.ttcn, line 84 */
const_FIRST__SGSN__IDX = 4;
module_object.add_function("f_cn_idx", (genericfunc_t)&f__cn__idx, NULL);
current_location.update_lineno(104);
/* HNBGW_Tests.ttcn, line 104 */
modulepar_mp__hnodeb__ip = cs_0;
module_object.add_modulepar("mp_hnodeb_ip");
current_location.update_lineno(105);
/* HNBGW_Tests.ttcn, line 105 */
modulepar_mp__hnodeb__port = -1;
module_object.add_modulepar("mp_hnodeb_port");
current_location.update_lineno(108);
/* HNBGW_Tests.ttcn, line 108 */
modulepar_mp__hnbgw__ip = cs_0;
module_object.add_modulepar("mp_hnbgw_ip");
current_location.update_lineno(109);
/* HNBGW_Tests.ttcn, line 109 */
modulepar_mp__hnbgw__iuh__port = 29169;
module_object.add_modulepar("mp_hnbgw_iuh_port");
current_location.update_lineno(110);
/* HNBGW_Tests.ttcn, line 110 */
modulepar_mp__hnbgw__ctrl__port = 4262;
module_object.add_modulepar("mp_hnbgw_ctrl_port");
current_location.update_lineno(113);
/* HNBGW_Tests.ttcn, line 113 */
modulepar_mp__local__statsd__ip = cs_0;
module_object.add_modulepar("mp_local_statsd_ip");
current_location.update_lineno(114);
/* HNBGW_Tests.ttcn, line 114 */
modulepar_mp__local__statsd__port = 8125;
module_object.add_modulepar("mp_local_statsd_port");
current_location.update_lineno(115);
/* HNBGW_Tests.ttcn, line 115 */
modulepar_mp__statsd__prefix = cs_1;
module_object.add_modulepar("mp_statsd_prefix");
current_location.update_lineno(117);
/* HNBGW_Tests.ttcn, line 117 */
modulepar_mp__mgw__ip = cs_0;
module_object.add_modulepar("mp_mgw_ip");
current_location.update_lineno(118);
/* HNBGW_Tests.ttcn, line 118 */
modulepar_mp__mgw__port = 2427;
module_object.add_modulepar("mp_mgw_port");
current_location.update_lineno(120);
/* HNBGW_Tests.ttcn, line 120 */
modulepar_mp__cn__cfg = NULL_VALUE;
module_object.add_modulepar("mp_cn_cfg");
current_location.update_lineno(122);
/* HNBGW_Tests.ttcn, line 122 */
modulepar_mp__enable__pfcp__tests = FALSE;
module_object.add_modulepar("mp_enable_pfcp_tests");
current_location.update_lineno(124);
/* HNBGW_Tests.ttcn, line 124 */
modulepar_mp__pfcp__ip__local = cs_0;
module_object.add_modulepar("mp_pfcp_ip_local");
current_location.update_lineno(127);
/* HNBGW_Tests.ttcn, line 127 */
modulepar_mp__pfcp__ip__remote = cs_2;
module_object.add_modulepar("mp_pfcp_ip_remote");
current_location.update_lineno(128);
/* HNBGW_Tests.ttcn, line 128 */
modulepar_mp__pfcp__upf__node__id = cs_3;
module_object.add_modulepar("mp_pfcp_upf_node_id");
current_location.update_lineno(130);
/* HNBGW_Tests.ttcn, line 130 */
modulepar_mp__validate__talloc__asn1 = TRUE;
module_object.add_modulepar("mp_validate_talloc_asn1");
current_location.update_lineno(134);
/* HNBGW_Tests.ttcn, line 134 */
modulepar_mp__hnbgw__timer__x31 = 5;
module_object.add_modulepar("mp_hnbgw_timer_x31");
module_object.add_function("MSC_UnitdataCallback", (genericfunc_t)&MSC__UnitdataCallback, (genericfunc_t)&start_MSC__UnitdataCallback);
current_location.update_lineno(143);
/* HNBGW_Tests.ttcn, line 143 */
const_MSC__RanOps.ranap__create__cb() = &RAN__Emulation::RanapExpectedCreateCallback;
const_MSC__RanOps.ranap__unitdata__cb() = &MSC__UnitdataCallback;
const_MSC__RanOps.ranap__connect__ind__auto__res() = TRUE;
const_MSC__RanOps.ps__domain() = FALSE;
const_MSC__RanOps.grnc__id() = OMIT_VALUE;
const_MSC__RanOps.decode__dtap() = FALSE;
const_MSC__RanOps.role__ms() = FALSE;
const_MSC__RanOps.protocol() = RAN__Emulation::RanProtocol::RAN__PROTOCOL__RANAP;
const_MSC__RanOps.transport() = RAN__Emulation::RAN__Transport::RANAP__TRANSPORT__IuCS;
const_MSC__RanOps.use__osmux() = FALSE;
const_MSC__RanOps.bssap__reset__retries() = 1;
const_MSC__RanOps.sccp__addr__local() = OMIT_VALUE;
const_MSC__RanOps.sccp__addr__peer() = OMIT_VALUE;
current_location.update_lineno(159);
/* HNBGW_Tests.ttcn, line 159 */
const_NUM__HNB = 2;
{
static const char * const port_name = "HNBAP";
test__CT_component_HNBAP.set_name(port_name);
}
module_object.add_altstep("as_Tguard", (genericfunc_t)&as__Tguard_instance, (genericfunc_t )&activate_as__Tguard, (genericfunc_t )&as__Tguard);
module_object.add_function("f_init_vty", (genericfunc_t)&f__init__vty, (genericfunc_t)&start_f__init__vty);
module_object.add_function("f_init_vty_stp", (genericfunc_t)&f__init__vty__stp, (genericfunc_t)&start_f__init__vty__stp);
module_object.add_function("f_vty_stp_hnbgw_asp_cmd", (genericfunc_t)&f__vty__stp__hnbgw__asp__cmd, (genericfunc_t)&start_f__vty__stp__hnbgw__asp__cmd);
module_object.add_function("f_init_mgcp", (genericfunc_t)&f__init__mgcp, (genericfunc_t)&start_f__init__mgcp);
module_object.add_function("f_statsd_pfcp_associated", (genericfunc_t)&f__statsd__pfcp__associated, (genericfunc_t)&start_f__statsd__pfcp__associated);
module_object.add_function("f_pfcp_wait_assoc_setup_req", (genericfunc_t)&f__pfcp__wait__assoc__setup__req, (genericfunc_t)&start_f__pfcp__wait__assoc__setup__req);
module_object.add_function("f_init_pfcp", (genericfunc_t)&f__init__pfcp, (genericfunc_t)&start_f__init__pfcp);
module_object.add_function("f_init_hnodeb", (genericfunc_t)&f__init__hnodeb, (genericfunc_t)&start_f__init__hnodeb);
module_object.add_function("f_drop_hnodeb", (genericfunc_t)&f__drop__hnodeb, (genericfunc_t)&start_f__drop__hnodeb);
module_object.add_function("f_vty_cnlink_allow_attach", (genericfunc_t)&f__vty__cnlink__allow__attach, NULL);
module_object.add_function("f_cn_nr_init", (genericfunc_t)&f__cn__nr__init, (genericfunc_t)&start_f__cn__nr__init);
module_object.add_function("f_cn_idx_disconnect", (genericfunc_t)&f__cn__idx__disconnect, (genericfunc_t)&start_f__cn__idx__disconnect);
module_object.add_function("f_init", (genericfunc_t)&f__init, (genericfunc_t)&start_f__init);
module_object.add_function("f_shutdown_helper", (genericfunc_t)&f__shutdown__helper, (genericfunc_t)&start_f__shutdown__helper);
module_object.add_function("f_start_hnbs", (genericfunc_t)&f__start__hnbs, (genericfunc_t)&start_f__start__hnbs);
module_object.add_function("f_hnb_ctr_prefix", (genericfunc_t)&f__hnb__ctr__prefix, NULL);
module_object.add_function("f_TestHdlrParams", (genericfunc_t)&f__TestHdlrParams, (genericfunc_t)&start_f__TestHdlrParams);
module_object.add_function("IuhRanapCreateCallback", (genericfunc_t)&IuhRanapCreateCallback, (genericfunc_t)&start_IuhRanapCreateCallback);
module_object.add_function("IuhRanapUnitdataCallback", (genericfunc_t)&IuhRanapUnitdataCallback, (genericfunc_t)&start_IuhRanapUnitdataCallback);
module_object.add_function("f_start_handler_create", (genericfunc_t)&f__start__handler__create, (genericfunc_t)&start_f__start__handler__create);
module_object.add_function("f_start_handler_run", (genericfunc_t)&f__start__handler__run, (genericfunc_t)&start_f__start__handler__run);
module_object.add_function("f_start_handler_with_pars", (genericfunc_t)&f__start__handler__with__pars, (genericfunc_t)&start_f__start__handler__with__pars);
module_object.add_function("f_ConnHdlrList_all_done", (genericfunc_t)&f__ConnHdlrList__all__done, (genericfunc_t)&start_f__ConnHdlrList__all__done);
module_object.add_function("f_hnbap_hnb_register", (genericfunc_t)&f__hnbap__hnb__register, (genericfunc_t)&start_f__hnbap__hnb__register);
module_object.add_function("f_hnbap_ue_register", (genericfunc_t)&f__hnbap__ue__register, (genericfunc_t)&start_f__hnbap__ue__register);
module_object.add_testcase_nonpard("TC_hnb_register", testcase_TC__hnb__register);
module_object.add_testcase_nonpard("TC_hnb_register_duplicate", testcase_TC__hnb__register__duplicate);
module_object.add_testcase_nonpard("TC_hnb_register_duplicate_reuse_sctp_assoc", testcase_TC__hnb__register__duplicate__reuse__sctp__assoc);
module_object.add_testcase_nonpard("TC_hnb_reregister_reuse_sctp_assoc", testcase_TC__hnb__reregister__reuse__sctp__assoc);
current_location.update_lineno(732);
/* HNBGW_Tests.ttcn, line 732 */
const_counternames__hnb.set_size(1);
{
Osmocom__CTRL__Functions::CounterNameVal& tmp_61 = const_counternames__hnb[0];
tmp_61.name() = cs_41;
tmp_61.val() = 0;
}
module_object.add_function("f_ctrs_hnb_init", (genericfunc_t)&f__ctrs__hnb__init, (genericfunc_t)&start_f__ctrs__hnb__init);
module_object.add_function("f_ctrs_hnb_verify", (genericfunc_t)&f__ctrs__hnb__verify, (genericfunc_t)&start_f__ctrs__hnb__verify);
module_object.add_function("f_ctrs_hnb_expect", (genericfunc_t)&f__ctrs__hnb__expect, (genericfunc_t)&start_f__ctrs__hnb__expect);
module_object.add_function("f_ctrs_hnb_add", (genericfunc_t)&f__ctrs__hnb__add, (genericfunc_t)&start_f__ctrs__hnb__add);
module_object.add_function("f_ctrs_hnb_set_all", (genericfunc_t)&f__ctrs__hnb__set__all, (genericfunc_t)&start_f__ctrs__hnb__set__all);
module_object.add_function("f_vty_run_hnbgw", (genericfunc_t)&f__vty__run__hnbgw, NULL);
module_object.add_testcase_nonpard("TC_hnb_disconnected_timeout", testcase_TC__hnb__disconnected__timeout);
module_object.add_testcase_nonpard("TC_ue_register", testcase_TC__ue__register);
module_object.add_testcase_nonpard("TC_ue_register_tmsi_lai", testcase_TC__ue__register__tmsi__lai);
module_object.add_testcase_nonpard("TC_ue_register_before_hnb_register", testcase_TC__ue__register__before__hnb__register);
module_object.add_function("f_tc_initial_ue", (genericfunc_t)&f__tc__initial__ue, (genericfunc_t)&start_f__tc__initial__ue);
module_object.add_testcase_nonpard("TC_ranap_cs_initial_ue", testcase_TC__ranap__cs__initial__ue);
module_object.add_testcase_nonpard("TC_ranap_ps_initial_ue", testcase_TC__ranap__ps__initial__ue);
module_object.add_function("f_vty_set_sccp_max_optional_data", (genericfunc_t)&f__vty__set__sccp__max__optional__data, NULL);
module_object.add_testcase_nonpard("TC_ranap_cs_initial_ue_empty_cr", testcase_TC__ranap__cs__initial__ue__empty__cr);
module_object.add_testcase_nonpard("TC_ranap_ps_initial_ue_empty_cr", testcase_TC__ranap__ps__initial__ue__empty__cr);
module_object.add_testcase_nonpard("TC_sccp_cr_limit", testcase_TC__sccp__cr__limit);
module_object.add_function("f_tc_rab_assignment", (genericfunc_t)&f__tc__rab__assignment, (genericfunc_t)&start_f__tc__rab__assignment);
module_object.add_testcase_nonpard("TC_rab_assignment", testcase_TC__rab__assignment);
module_object.add_function("f_tc_rab_assignment_concurrent", (genericfunc_t)&f__tc__rab__assignment__concurrent, (genericfunc_t)&start_f__tc__rab__assignment__concurrent);
module_object.add_testcase_nonpard("TC_rab_assignment_concurrent", testcase_TC__rab__assignment__concurrent);
module_object.add_function("f_tc_rab_assign_fail", (genericfunc_t)&f__tc__rab__assign__fail, (genericfunc_t)&start_f__tc__rab__assign__fail);
module_object.add_testcase_nonpard("TC_rab_assign_fail", testcase_TC__rab__assign__fail);
module_object.add_function("f_tc_rab_release", (genericfunc_t)&f__tc__rab__release, (genericfunc_t)&start_f__tc__rab__release);
module_object.add_testcase_nonpard("TC_rab_release", testcase_TC__rab__release);
module_object.add_testcase_nonpard("TC_rab_release_abnormal", testcase_TC__rab__release__abnormal);
module_object.add_function("f_tc_rab_assign_mgcp_to", (genericfunc_t)&f__tc__rab__assign__mgcp__to, (genericfunc_t)&start_f__tc__rab__assign__mgcp__to);
module_object.add_testcase_nonpard("TC_rab_assign_mgcp_to", testcase_TC__rab__assign__mgcp__to);
module_object.add_testcase_nonpard("TC_rab_assign_mgw_iuup_addr_chg", testcase_TC__rab__assign__mgw__iuup__addr__chg);
module_object.add_function("f_tc_ranap_bidir", (genericfunc_t)&f__tc__ranap__bidir, (genericfunc_t)&start_f__tc__ranap__bidir);
module_object.add_testcase_nonpard("TC_ranap_cs_bidir", testcase_TC__ranap__cs__bidir);
module_object.add_testcase_nonpard("TC_ranap_ps_bidir", testcase_TC__ranap__ps__bidir);
module_object.add_function("f_tc_ranap_mo_disconnect", (genericfunc_t)&f__tc__ranap__mo__disconnect, (genericfunc_t)&start_f__tc__ranap__mo__disconnect);
module_object.add_testcase_nonpard("TC_ranap_cs_mo_disconnect", testcase_TC__ranap__cs__mo__disconnect);
module_object.add_testcase_nonpard("TC_ranap_ps_mo_disconnect", testcase_TC__ranap__ps__mo__disconnect);
module_object.add_function("f_tc_ranap_creq_cref_ConnHdlr", (genericfunc_t)&f__tc__ranap__creq__cref__ConnHdlr, (genericfunc_t)&start_f__tc__ranap__creq__cref__ConnHdlr);
module_object.add_function("f_tc_ranap_creq_cref", (genericfunc_t)&f__tc__ranap__creq__cref, (genericfunc_t)&start_f__tc__ranap__creq__cref);
module_object.add_testcase_nonpard("TC_ranap_cs_creq_cref", testcase_TC__ranap__cs__creq__cref);
module_object.add_testcase_nonpard("TC_ranap_ps_creq_cref", testcase_TC__ranap__ps__creq__cref);
module_object.add_function("f_tc_rua_disconnect_during_sccp_cr_cc", (genericfunc_t)&f__tc__rua__disconnect__during__sccp__cr__cc, (genericfunc_t)&start_f__tc__rua__disconnect__during__sccp__cr__cc);
module_object.add_function("f_TC_rua_disconnect_during_sccp_cr_cc", (genericfunc_t)&f__TC__rua__disconnect__during__sccp__cr__cc, (genericfunc_t)&start_f__TC__rua__disconnect__during__sccp__cr__cc);
module_object.add_testcase_nonpard("TC_cs_rua_disconnect_during_sccp_cr_cc", testcase_TC__cs__rua__disconnect__during__sccp__cr__cc);
module_object.add_testcase_nonpard("TC_ps_rua_disconnect_during_sccp_cr_cc", testcase_TC__ps__rua__disconnect__during__sccp__cr__cc);
module_object.add_function("f_tc_cs_iu_release_req_rua_disconnect", (genericfunc_t)&f__tc__cs__iu__release__req__rua__disconnect, (genericfunc_t)&start_f__tc__cs__iu__release__req__rua__disconnect);
module_object.add_testcase_nonpard("TC_cs_iu_release_req_rua_disconnect", testcase_TC__cs__iu__release__req__rua__disconnect);
module_object.add_function("f_tc_ps_iu_release_req_rua_disconnect", (genericfunc_t)&f__tc__ps__iu__release__req__rua__disconnect, (genericfunc_t)&start_f__tc__ps__iu__release__req__rua__disconnect);
module_object.add_testcase_nonpard("TC_ps_iu_release_req_rua_disconnect", testcase_TC__ps__iu__release__req__rua__disconnect);
module_object.add_function("f_tc_rua_dt_during_sccp_wait_cc", (genericfunc_t)&f__tc__rua__dt__during__sccp__wait__cc, (genericfunc_t)&start_f__tc__rua__dt__during__sccp__wait__cc);
module_object.add_function("f_TC_rua_dt_during_sccp_wait_cc", (genericfunc_t)&f__TC__rua__dt__during__sccp__wait__cc, (genericfunc_t)&start_f__TC__rua__dt__during__sccp__wait__cc);
module_object.add_testcase_nonpard("TC_cs_rua_dt_during_sccp_wait_cc", testcase_TC__cs__rua__dt__during__sccp__wait__cc);
module_object.add_testcase_nonpard("TC_ps_rua_dt_during_sccp_wait_cc", testcase_TC__ps__rua__dt__during__sccp__wait__cc);
module_object.add_function("f_tc_ps_rab_assignment", (genericfunc_t)&f__tc__ps__rab__assignment, (genericfunc_t)&start_f__tc__ps__rab__assignment);
module_object.add_testcase_nonpard("TC_ps_rab_assignment", testcase_TC__ps__rab__assignment);
module_object.add_testcase_nonpard("TC_ps_rab_assignment_concurrent", testcase_TC__ps__rab__assignment__concurrent);
module_object.add_function("f_ps_tc_rab_release", (genericfunc_t)&f__ps__tc__rab__release, (genericfunc_t)&start_f__ps__tc__rab__release);
module_object.add_testcase_nonpard("TC_ps_rab_release", testcase_TC__ps__rab__release);
module_object.add_testcase_nonpard("TC_ps_rab_release_abnormal", testcase_TC__ps__rab__release__abnormal);
current_location.update_lineno(1671);
/* HNBGW_Tests.ttcn, line 1671 */
const_counternames__cnpool.set_size(5);
{
Osmocom__CTRL__Functions::CounterNameVal& tmp_223 = const_counternames__cnpool[0];
tmp_223.name() = cs_63;
tmp_223.val() = 0;
}
{
Osmocom__CTRL__Functions::CounterNameVal& tmp_224 = const_counternames__cnpool[1];
tmp_224.name() = cs_64;
tmp_224.val() = 0;
}
{
Osmocom__CTRL__Functions::CounterNameVal& tmp_225 = const_counternames__cnpool[2];
tmp_225.name() = cs_65;
tmp_225.val() = 0;
}
{
Osmocom__CTRL__Functions::CounterNameVal& tmp_226 = const_counternames__cnpool[3];
tmp_226.name() = cs_66;
tmp_226.val() = 0;
}
{
Osmocom__CTRL__Functions::CounterNameVal& tmp_227 = const_counternames__cnpool[4];
tmp_227.name() = cs_67;
tmp_227.val() = 0;
}
module_object.add_function("f_ctrs_cn_init", (genericfunc_t)&f__ctrs__cn__init, (genericfunc_t)&start_f__ctrs__cn__init);
module_object.add_function("f_ctrs_cn_verify", (genericfunc_t)&f__ctrs__cn__verify, (genericfunc_t)&start_f__ctrs__cn__verify);
module_object.add_function("f_ctrs_cn_expect", (genericfunc_t)&f__ctrs__cn__expect, (genericfunc_t)&start_f__ctrs__cn__expect);
module_object.add_function("f_ctrs_cn_add", (genericfunc_t)&f__ctrs__cn__add, (genericfunc_t)&start_f__ctrs__cn__add);
module_object.add_function("f_tc_cnpool_compl_l3", (genericfunc_t)&f__tc__cnpool__compl__l3, (genericfunc_t)&start_f__tc__cnpool__compl__l3);
module_object.add_function("f_TC_cnpool_compl_l3", (genericfunc_t)&f__TC__cnpool__compl__l3, (genericfunc_t)&start_f__TC__cnpool__compl__l3);
module_object.add_function("f_TC_cnpool_compl_l3_list", (genericfunc_t)&f__TC__cnpool__compl__l3__list, (genericfunc_t)&start_f__TC__cnpool__compl__l3__list);
module_object.add_function("f_gen_one_compl_l3", (genericfunc_t)&f__gen__one__compl__l3, NULL);
module_object.add_function("f_gen_compl_l3", (genericfunc_t)&f__gen__compl__l3, NULL);
module_object.add_function("f_gen_mi_imsi", (genericfunc_t)&f__gen__mi__imsi, NULL);
module_object.add_function("f_gen_mi_imsis", (genericfunc_t)&f__gen__mi__imsis, NULL);
module_object.add_function("f_vty_set_roundrobin_next", (genericfunc_t)&f__vty__set__roundrobin__next, NULL);
module_object.add_function("f_gen_compl3_by_domain", (genericfunc_t)&f__gen__compl3__by__domain, NULL);
module_object.add_testcase_nonpard("TC_mscpool_L3Compl_on_1_cnlink", testcase_TC__mscpool__L3Compl__on__1__cnlink);
module_object.add_testcase_nonpard("TC_sgsnpool_L3Compl_on_1_cnlink", testcase_TC__sgsnpool__L3Compl__on__1__cnlink);
module_object.add_function("f_TC_cnpool_L3Compl_on_1_cnlink", (genericfunc_t)&f__TC__cnpool__L3Compl__on__1__cnlink, (genericfunc_t)&start_f__TC__cnpool__L3Compl__on__1__cnlink);
module_object.add_testcase_nonpard("TC_mscpool_L3Complete_by_imsi_round_robin", testcase_TC__mscpool__L3Complete__by__imsi__round__robin);
module_object.add_testcase_nonpard("TC_sgsnpool_L3Complete_no_nri_round_robin", testcase_TC__sgsnpool__L3Complete__no__nri__round__robin);
module_object.add_function("f_TC_cnpool_L3Complete_by_imsi_round_robin", (genericfunc_t)&f__TC__cnpool__L3Complete__by__imsi__round__robin, (genericfunc_t)&start_f__TC__cnpool__L3Complete__by__imsi__round__robin);
module_object.add_testcase_nonpard("TC_mscpool_LU_by_tmsi_null_nri_0_round_robin", testcase_TC__mscpool__LU__by__tmsi__null__nri__0__round__robin);
module_object.add_testcase_nonpard("TC_mscpool_LU_by_tmsi_null_nri_1_round_robin", testcase_TC__mscpool__LU__by__tmsi__null__nri__1__round__robin);
module_object.add_function("f_TC_cnpool_LU_by_tmsi_null_nri_N_round_robin", (genericfunc_t)&f__TC__cnpool__LU__by__tmsi__null__nri__N__round__robin, (genericfunc_t)&start_f__TC__cnpool__LU__by__tmsi__null__nri__N__round__robin);
module_object.add_testcase_nonpard("TC_mscpool_L3Complete_by_tmsi_unassigned_nri_round_robin", testcase_TC__mscpool__L3Complete__by__tmsi__unassigned__nri__round__robin);
module_object.add_function("f_TC_cnpool_L3Complete_by_tmsi_unassigned_nri_round_robin", (genericfunc_t)&f__TC__cnpool__L3Complete__by__tmsi__unassigned__nri__round__robin, (genericfunc_t)&start_f__TC__cnpool__L3Complete__by__tmsi__unassigned__nri__round__robin);
module_object.add_testcase_nonpard("TC_mscpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin", testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin);
module_object.add_function("f_TC_cnpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin", (genericfunc_t)&f__TC__cnpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin, (genericfunc_t)&start_f__TC__cnpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin);
module_object.add_testcase_nonpard("TC_mscpool_L3Complete_by_tmsi_valid_nri_1", testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__1);
module_object.add_testcase_nonpard("TC_sgsnpool_L3Complete_valid_nri_1", testcase_TC__sgsnpool__L3Complete__valid__nri__1);
module_object.add_function("f_TC_cnpool_L3Complete_valid_nri_1", (genericfunc_t)&f__TC__cnpool__L3Complete__valid__nri__1, (genericfunc_t)&start_f__TC__cnpool__L3Complete__valid__nri__1);
module_object.add_testcase_nonpard("TC_mscpool_L3Complete_by_tmsi_valid_nri_2", testcase_TC__mscpool__L3Complete__by__tmsi__valid__nri__2);
module_object.add_testcase_nonpard("TC_sgsnpool_L3Complete_valid_nri_2", testcase_TC__sgsnpool__L3Complete__valid__nri__2);
module_object.add_function("f_TC_cnpool_L3Complete_valid_nri_2", (genericfunc_t)&f__TC__cnpool__L3Complete__valid__nri__2, (genericfunc_t)&start_f__TC__cnpool__L3Complete__valid__nri__2);
module_object.add_testcase_nonpard("TC_mscpool_LU_by_tmsi_from_other_PLMN", testcase_TC__mscpool__LU__by__tmsi__from__other__PLMN);
module_object.add_testcase_nonpard("TC_sgsnpool_nri_from_other_PLMN", testcase_TC__sgsnpool__nri__from__other__PLMN);
module_object.add_function("f_TC_cnpool_nri_from_other_PLMN", (genericfunc_t)&f__TC__cnpool__nri__from__other__PLMN, (genericfunc_t)&start_f__TC__cnpool__nri__from__other__PLMN);
module_object.add_function("f_tc_mscpool_paging_imsi", (genericfunc_t)&f__tc__mscpool__paging__imsi, (genericfunc_t)&start_f__tc__mscpool__paging__imsi);
module_object.add_testcase_nonpard("TC_mscpool_paging_imsi", testcase_TC__mscpool__paging__imsi);
module_object.add_function("f_tc_mscpool_paging_tmsi", (genericfunc_t)&f__tc__mscpool__paging__tmsi, (genericfunc_t)&start_f__tc__mscpool__paging__tmsi);
module_object.add_testcase_nonpard("TC_mscpool_paging_tmsi", testcase_TC__mscpool__paging__tmsi);
module_object.add_function("f_tc_mscpool_paging_imsi_lai_registered", (genericfunc_t)&f__tc__mscpool__paging__imsi__lai__registered, (genericfunc_t)&start_f__tc__mscpool__paging__imsi__lai__registered);
module_object.add_testcase_nonpard("TC_mscpool_paging_imsi_lai_registered", testcase_TC__mscpool__paging__imsi__lai__registered);
module_object.add_function("f_tc_mscpool_paging_imsi_rai_registered", (genericfunc_t)&f__tc__mscpool__paging__imsi__rai__registered, (genericfunc_t)&start_f__tc__mscpool__paging__imsi__rai__registered);
module_object.add_testcase_nonpard("TC_mscpool_paging_imsi_rai_registered", testcase_TC__mscpool__paging__imsi__rai__registered);
module_object.add_testcase_nonpard("TC_mscpool_no_allow_attach_round_robin", testcase_TC__mscpool__no__allow__attach__round__robin);
module_object.add_testcase_nonpard("TC_mscpool_no_allow_attach_valid_nri", testcase_TC__mscpool__no__allow__attach__valid__nri);
module_object.add_testcase_nonpard("TC_mscpool_sccp_n_pcstate_detaches_cnlink", testcase_TC__mscpool__sccp__n__pcstate__detaches__cnlink);
module_object.add_testcase_nonpard("TC_sgsnpool_sccp_n_pcstate_detaches_cnlink", testcase_TC__sgsnpool__sccp__n__pcstate__detaches__cnlink);
module_object.add_function("f_TC_cnpool_sccp_n_pcstate_detaches_cnlink", (genericfunc_t)&f__TC__cnpool__sccp__n__pcstate__detaches__cnlink, (genericfunc_t)&start_f__TC__cnpool__sccp__n__pcstate__detaches__cnlink);
module_object.add_testcase_nonpard("TC_mscpool_sccp_n_pcstate_attaches_cnlink", testcase_TC__mscpool__sccp__n__pcstate__attaches__cnlink);
module_object.add_testcase_nonpard("TC_sgsnpool_sccp_n_pcstate_attaches_cnlink", testcase_TC__sgsnpool__sccp__n__pcstate__attaches__cnlink);
module_object.add_function("f_TC_cnpool_sccp_n_pcstate_attaches_cnlink", (genericfunc_t)&f__TC__cnpool__sccp__n__pcstate__attaches__cnlink, (genericfunc_t)&start_f__TC__cnpool__sccp__n__pcstate__attaches__cnlink);
module_object.add_function("f_vty_add_sccp_addr", (genericfunc_t)&f__vty__add__sccp__addr, NULL);
module_object.add_function("f_vty_set_cnlink_addr", (genericfunc_t)&f__vty__set__cnlink__addr, NULL);
module_object.add_function("f_vty_apply_sccp", (genericfunc_t)&f__vty__apply__sccp, NULL);
module_object.add_function("f_tc_apply_sccp", (genericfunc_t)&f__tc__apply__sccp, (genericfunc_t)&start_f__tc__apply__sccp);
module_object.add_testcase_nonpard("TC_apply_sccp", testcase_TC__apply__sccp);
module_object.add_function("f_tc_second_rab_assignment", (genericfunc_t)&f__tc__second__rab__assignment, (genericfunc_t)&start_f__tc__second__rab__assignment);
module_object.add_testcase_nonpard("TC_second_rab_assignment", testcase_TC__second__rab__assignment);
module_object.add_function("f_TC_cnpool_L3Compl_no_cn", (genericfunc_t)&f__TC__cnpool__L3Compl__no__cn, (genericfunc_t)&start_f__TC__cnpool__L3Compl__no__cn);
module_object.add_testcase_nonpard("TC_mscpool_L3Compl_no_cn", testcase_TC__mscpool__L3Compl__no__cn);
module_object.add_testcase_nonpard("TC_sgsnpool_L3Compl_no_cn", testcase_TC__sgsnpool__L3Compl__no__cn);
module_object.add_function("f_TC_stat_stp_sctp_disconnected_UnitdataCallback", (genericfunc_t)&f__TC__stat__stp__sctp__disconnected__UnitdataCallback, (genericfunc_t)&start_f__TC__stat__stp__sctp__disconnected__UnitdataCallback);
module_object.add_testcase_nonpard("TC_stat_stp_sctp_disconnected", testcase_TC__stat__stp__sctp__disconnected);
}

void post_init_module()
{
TTCN_Location current_location("HNBGW_Tests.ttcn", 0, TTCN_Location::LOCATION_UNKNOWN, "HNBGW_Tests");
ConnHdlr::module_object.post_init_module();
current_location.update_lineno(94);
/* HNBGW_Tests.ttcn, line 94 */
const_f__cn__idx_cn__nr_defval = 0;
current_location.update_lineno(203);
/* HNBGW_Tests.ttcn, line 203 */
const_f__init__vty_id_defval = cs_4;
current_location.update_lineno(261);
/* HNBGW_Tests.ttcn, line 261 */
const_f__pfcp__wait__assoc__setup__req_fail__timeout_defval = TRUE;
current_location.update_lineno(407);
/* HNBGW_Tests.ttcn, line 407 */
const_f__init_id_defval = cs_26;
current_location.update_lineno(407);
/* HNBGW_Tests.ttcn, line 407 */
const_f__init_guard__timeout_defval = 4.5e1;
current_location.update_lineno(407);
/* HNBGW_Tests.ttcn, line 407 */
const_f__init_nr__msc_defval = 1;
current_location.update_lineno(407);
/* HNBGW_Tests.ttcn, line 407 */
const_f__init_nr__sgsn_defval = 1;
current_location.update_lineno(408);
/* HNBGW_Tests.ttcn, line 408 */
const_f__init_start__hnb_defval = TRUE;
current_location.update_lineno(517);
/* HNBGW_Tests.ttcn, line 517 */
const_f__TestHdlrParams_ps__domain_defval = FALSE;
current_location.update_lineno(518);
/* HNBGW_Tests.ttcn, line 518 */
const_f__TestHdlrParams_expect__separate__sccp__cr_defval = FALSE;
current_location.update_lineno(519);
/* HNBGW_Tests.ttcn, line 519 */
const_f__TestHdlrParams_tx__sccp__cr__data__len_defval = 0;
current_location.update_lineno(520);
/* HNBGW_Tests.ttcn, line 520 */
const_f__TestHdlrParams_expect__compl__l3__success_defval = TRUE;
current_location.update_lineno(521);
/* HNBGW_Tests.ttcn, line 521 */
const_f__TestHdlrParams_cn__nr_defval = 0;
current_location.update_lineno(522);
/* HNBGW_Tests.ttcn, line 522 */
template_f__TestHdlrParams_rab__rel__cause_defval = RANAP__Templates::ts__RanapCause__nas__normal;
current_location.update_lineno(615);
/* HNBGW_Tests.ttcn, line 615 */
const_f__hnbap__hnb__register_hnb__idx_defval = 0;
current_location.update_lineno(615);
/* HNBGW_Tests.ttcn, line 615 */
const_f__hnbap__hnb__register_expect__reject_defval = FALSE;
current_location.update_lineno(651);
/* HNBGW_Tests.ttcn, line 651 */
const_f__hnbap__ue__register_hnb__idx_defval = 0;
current_location.update_lineno(651);
/* HNBGW_Tests.ttcn, line 651 */
const_f__hnbap__ue__register_expect__reject_defval = FALSE;
current_location.update_lineno(736);
/* HNBGW_Tests.ttcn, line 736 */
const_f__ctrs__hnb__init_hnb__start_defval = 0;
current_location.update_lineno(736);
/* HNBGW_Tests.ttcn, line 736 */
const_f__ctrs__hnb__init_hnb__count_defval = 1;
current_location.update_lineno(737);
/* HNBGW_Tests.ttcn, line 737 */
const_f__ctrs__hnb__init_counternames_defval = counternames__hnb;
current_location.update_lineno(762);
/* HNBGW_Tests.ttcn, line 762 */
const_f__ctrs__hnb__expect_val_defval = 1;
current_location.update_lineno(767);
/* HNBGW_Tests.ttcn, line 767 */
const_f__ctrs__hnb__add_val_defval = 1;
current_location.update_lineno(902);
/* HNBGW_Tests.ttcn, line 902 */
const_f__vty__set__sccp__max__optional__data_val_defval = -1;
current_location.update_lineno(1678);
/* HNBGW_Tests.ttcn, line 1678 */
const_f__ctrs__cn__init_cn__count_defval = 0;
current_location.update_lineno(1679);
/* HNBGW_Tests.ttcn, line 1679 */
const_f__ctrs__cn__init_counternames_defval = counternames__cnpool;
current_location.update_lineno(1715);
/* HNBGW_Tests.ttcn, line 1715 */
const_f__ctrs__cn__expect_val_defval = 1;
current_location.update_lineno(1720);
/* HNBGW_Tests.ttcn, line 1720 */
const_f__ctrs__cn__add_val_defval = 1;
current_location.update_lineno(1729);
/* HNBGW_Tests.ttcn, line 1729 */
template_f__TC__cnpool__compl__l3_inc__countername_defval = OMIT_VALUE;
current_location.update_lineno(1730);
/* HNBGW_Tests.ttcn, line 1730 */
const_f__TC__cnpool__compl__l3_expect__compl__l3__success_defval = TRUE;
current_location.update_lineno(1746);
/* HNBGW_Tests.ttcn, line 1746 */
const_f__TC__cnpool__compl__l3__list_expect__compl__l3__success_defval = TRUE;
current_location.update_lineno(1772);
/* HNBGW_Tests.ttcn, line 1772 */
const_f__gen__one__compl__l3_ps__nri_defval = -1;
current_location.update_lineno(1856);
/* HNBGW_Tests.ttcn, line 1856 */
template_f__gen__compl3__by__domain_mis_defval = OMIT_VALUE;
current_location.update_lineno(2497);
/* HNBGW_Tests.ttcn, line 2497 */
const_f__vty__add__sccp__addr_cs7__nr_defval = 0;
}

boolean set_module_param(Module_Param& param)
{
const char* const par_name = param.get_id()->get_current_name();
if (!strcmp(par_name, "mp_hnodeb_ip")) {
modulepar_mp__hnodeb__ip.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_hnodeb_port")) {
modulepar_mp__hnodeb__port.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_hnbgw_ip")) {
modulepar_mp__hnbgw__ip.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_hnbgw_iuh_port")) {
modulepar_mp__hnbgw__iuh__port.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_hnbgw_ctrl_port")) {
modulepar_mp__hnbgw__ctrl__port.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_local_statsd_ip")) {
modulepar_mp__local__statsd__ip.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_local_statsd_port")) {
modulepar_mp__local__statsd__port.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_statsd_prefix")) {
modulepar_mp__statsd__prefix.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_mgw_ip")) {
modulepar_mp__mgw__ip.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_mgw_port")) {
modulepar_mp__mgw__port.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_cn_cfg")) {
modulepar_mp__cn__cfg.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_enable_pfcp_tests")) {
modulepar_mp__enable__pfcp__tests.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_pfcp_ip_local")) {
modulepar_mp__pfcp__ip__local.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_pfcp_ip_remote")) {
modulepar_mp__pfcp__ip__remote.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_pfcp_upf_node_id")) {
modulepar_mp__pfcp__upf__node__id.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_validate_talloc_asn1")) {
modulepar_mp__validate__talloc__asn1.set_param(param);
return TRUE;
} else if (!strcmp(par_name, "mp_hnbgw_timer_x31")) {
modulepar_mp__hnbgw__timer__x31.set_param(param);
return TRUE;
} else return FALSE;
}

void log_module_param()
{
TTCN_Logger::log_event_str("mp_hnodeb_ip := ");
mp__hnodeb__ip.log();
TTCN_Logger::log_event_str(", mp_hnodeb_port := ");
mp__hnodeb__port.log();
TTCN_Logger::log_event_str(", mp_hnbgw_ip := ");
mp__hnbgw__ip.log();
TTCN_Logger::log_event_str(", mp_hnbgw_iuh_port := ");
mp__hnbgw__iuh__port.log();
TTCN_Logger::log_event_str(", mp_hnbgw_ctrl_port := ");
mp__hnbgw__ctrl__port.log();
TTCN_Logger::log_event_str(", mp_local_statsd_ip := ");
mp__local__statsd__ip.log();
TTCN_Logger::log_event_str(", mp_local_statsd_port := ");
mp__local__statsd__port.log();
TTCN_Logger::log_event_str(", mp_statsd_prefix := ");
mp__statsd__prefix.log();
TTCN_Logger::log_event_str(", mp_mgw_ip := ");
mp__mgw__ip.log();
TTCN_Logger::log_event_str(", mp_mgw_port := ");
mp__mgw__port.log();
TTCN_Logger::log_event_str(", mp_cn_cfg := ");
mp__cn__cfg.log();
TTCN_Logger::log_event_str(", mp_enable_pfcp_tests := ");
mp__enable__pfcp__tests.log();
TTCN_Logger::log_event_str(", mp_pfcp_ip_local := ");
mp__pfcp__ip__local.log();
TTCN_Logger::log_event_str(", mp_pfcp_ip_remote := ");
mp__pfcp__ip__remote.log();
TTCN_Logger::log_event_str(", mp_pfcp_upf_node_id := ");
mp__pfcp__upf__node__id.log();
TTCN_Logger::log_event_str(", mp_validate_talloc_asn1 := ");
mp__validate__talloc__asn1.log();
TTCN_Logger::log_event_str(", mp_hnbgw_timer_x31 := ");
mp__hnbgw__timer__x31.log();
}

boolean init_comp_type(const char *component_type, boolean init_base_comps)
{
(void)init_base_comps;
if (!strcmp(component_type, "test_CT")) {
if (init_base_comps) {
Module_List::initialize_component("Osmocom_CTRL_Adapter", "CTRL_Adapter_CT", FALSE);
Module_List::initialize_component("PFCP_Emulation", "PFCP_ConnHdlr", FALSE);
Module_List::initialize_component("StatsD_Checker", "StatsD_ConnHdlr", FALSE);
}
test__CT_component_g__initialized = FALSE;
test__CT_component_g__cn.clean_up();
test__CT_component_g__hnb__cfg.clean_up();
test__CT_component_vc__Iuh.clean_up();
test__CT_component_vc__RUA.clean_up();
test__CT_component_HNBAP.activate_port();
test__CT_component_g__num__hnbs = 2;
test__CT_component_vc__MGCP.clean_up();
test__CT_component_HNBGWVTY.activate_port();
test__CT_component_STPVTY.activate_port();
test__CT_component_vc__STATSD.clean_up();
test__CT_component_vc__PFCP.clean_up();
test__CT_component_g__statd__timeout = 5.0;
test__CT_component_g__ctr__cn__node__name.clean_up();
test__CT_component_g__ctr__cn.clean_up();
test__CT_component_g__ctr__hnb.clean_up();
test__CT_component_g__ran__ops = MSC__RanOps;
test__CT_component_vc__mutex__disp.clean_up();
return TRUE;
} else return FALSE;
}

boolean init_system_port(const char* component_type, const char* port_name)
{
if (!strcmp(component_type, "test_CT")) {
if (!strcmp(port_name, "HNBAP")) {
test__CT_component_HNBAP.safe_start();
return TRUE;
}
if (!strcmp(port_name, "HNBGWVTY")) {
test__CT_component_HNBGWVTY.safe_start();
return TRUE;
}
if (!strcmp(port_name, "IPA_CTRL")) {
Osmocom__CTRL__Adapter::CTRL__Adapter__CT_component_IPA__CTRL.safe_start();
return TRUE;
}
if (!strcmp(port_name, "PFCP")) {
PFCP__Emulation::PFCP__ConnHdlr_component_PFCP.safe_start();
return TRUE;
}
if (!strcmp(port_name, "PFCP_PROC")) {
PFCP__Emulation::PFCP__ConnHdlr_component_PFCP__PROC.safe_start();
return TRUE;
}
if (!strcmp(port_name, "STATSD_PROC")) {
StatsD__Checker::StatsD__ConnHdlr_component_STATSD__PROC.safe_start();
return TRUE;
}
if (!strcmp(port_name, "STPVTY")) {
test__CT_component_STPVTY.safe_start();
return TRUE;
}
}
return FALSE;
}

boolean start_ptc_function(const char *function_name, Text_Buf& function_arguments)
{
if (!strcmp(function_name, "MSC_UnitdataCallback")) {
RANAP__PDU__Descriptions::RANAP__PDU ranap;
ranap.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function MSC_UnitdataCallback(");
ranap.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
MSC__UnitdataCallback(ranap);
TTCN_Runtime::function_finished("MSC_UnitdataCallback");
return TRUE;
} else if (!strcmp(function_name, "f_init_vty")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_vty(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__init__vty(id);
TTCN_Runtime::function_finished("f_init_vty");
return TRUE;
} else if (!strcmp(function_name, "f_init_vty_stp")) {
TTCN_Logger::log_str(TTCN_Logger::PARALLEL_PTC, "Starting function f_init_vty_stp().");
TTCN_Runtime::function_started(function_arguments);
f__init__vty__stp();
TTCN_Runtime::function_finished("f_init_vty_stp");
return TRUE;
} else if (!strcmp(function_name, "f_vty_stp_hnbgw_asp_cmd")) {
CHARSTRING cmd;
cmd.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_vty_stp_hnbgw_asp_cmd(");
cmd.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__vty__stp__hnbgw__asp__cmd(cmd);
TTCN_Runtime::function_finished("f_vty_stp_hnbgw_asp_cmd");
return TRUE;
} else if (!strcmp(function_name, "f_init_mgcp")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_mgcp(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__init__mgcp(id);
TTCN_Runtime::function_finished("f_init_mgcp");
return TRUE;
} else if (!strcmp(function_name, "f_statsd_pfcp_associated")) {
TTCN_Logger::log_str(TTCN_Logger::PARALLEL_PTC, "Starting function f_statsd_pfcp_associated().");
TTCN_Runtime::function_started(function_arguments);
f__statsd__pfcp__associated();
TTCN_Runtime::function_finished("f_statsd_pfcp_associated");
return TRUE;
} else if (!strcmp(function_name, "f_pfcp_wait_assoc_setup_req")) {
BOOLEAN fail__timeout;
fail__timeout.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_pfcp_wait_assoc_setup_req(");
fail__timeout.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__pfcp__wait__assoc__setup__req(fail__timeout);
TTCN_Runtime::function_finished("f_pfcp_wait_assoc_setup_req");
return TRUE;
} else if (!strcmp(function_name, "f_init_pfcp")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_pfcp(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__init__pfcp(id);
TTCN_Runtime::function_finished("f_init_pfcp");
return TRUE;
} else if (!strcmp(function_name, "f_init_hnodeb")) {
CHARSTRING id;
INTEGER hnb__idx;
RUA__Emulation::RuaOps rua__ops;
id.decode_text(function_arguments);
hnb__idx.decode_text(function_arguments);
rua__ops.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init_hnodeb(");
id.log();
TTCN_Logger::log_event_str(", ");
hnb__idx.log();
TTCN_Logger::log_event_str(", ");
rua__ops.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__init__hnodeb(id, hnb__idx, rua__ops);
TTCN_Runtime::function_finished("f_init_hnodeb");
return TRUE;
} else if (!strcmp(function_name, "f_drop_hnodeb")) {
INTEGER hnb__idx;
hnb__idx.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_drop_hnodeb(");
hnb__idx.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__drop__hnodeb(hnb__idx);
TTCN_Runtime::function_finished("f_drop_hnodeb");
return TRUE;
} else if (!strcmp(function_name, "f_cn_nr_init")) {
BOOLEAN ps__domain;
INTEGER cn__nr;
ps__domain.decode_text(function_arguments);
cn__nr.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_cn_nr_init(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
cn__nr.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__cn__nr__init(ps__domain, cn__nr);
TTCN_Runtime::function_finished("f_cn_nr_init");
return TRUE;
} else if (!strcmp(function_name, "f_cn_idx_disconnect")) {
INTEGER cn__idx;
cn__idx.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_cn_idx_disconnect(");
cn__idx.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__cn__idx__disconnect(cn__idx);
TTCN_Runtime::function_finished("f_cn_idx_disconnect");
return TRUE;
} else if (!strcmp(function_name, "f_init")) {
CHARSTRING id;
FLOAT guard__timeout;
INTEGER nr__msc;
INTEGER nr__sgsn;
BOOLEAN start__hnb;
id.decode_text(function_arguments);
guard__timeout.decode_text(function_arguments);
nr__msc.decode_text(function_arguments);
nr__sgsn.decode_text(function_arguments);
start__hnb.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_init(");
id.log();
TTCN_Logger::log_event_str(", ");
guard__timeout.log();
TTCN_Logger::log_event_str(", ");
nr__msc.log();
TTCN_Logger::log_event_str(", ");
nr__sgsn.log();
TTCN_Logger::log_event_str(", ");
start__hnb.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__init(id, guard__timeout, nr__msc, nr__sgsn, start__hnb);
TTCN_Runtime::function_finished("f_init");
return TRUE;
} else if (!strcmp(function_name, "f_shutdown_helper")) {
TTCN_Logger::log_str(TTCN_Logger::PARALLEL_PTC, "Starting function f_shutdown_helper().");
TTCN_Runtime::function_started(function_arguments);
f__shutdown__helper();
TTCN_Runtime::function_finished("f_shutdown_helper");
return TRUE;
} else if (!strcmp(function_name, "f_start_hnbs")) {
TTCN_Logger::log_str(TTCN_Logger::PARALLEL_PTC, "Starting function f_start_hnbs().");
TTCN_Runtime::function_started(function_arguments);
f__start__hnbs();
TTCN_Runtime::function_finished("f_start_hnbs");
return TRUE;
} else if (!strcmp(function_name, "f_TestHdlrParams")) {
INTEGER imsi__suffix;
BOOLEAN ps__domain;
BOOLEAN expect__separate__sccp__cr;
INTEGER tx__sccp__cr__data__len;
BOOLEAN expect__compl__l3__success;
INTEGER cn__nr;
RANAP__IEs::Cause_template rab__rel__cause;
imsi__suffix.decode_text(function_arguments);
ps__domain.decode_text(function_arguments);
expect__separate__sccp__cr.decode_text(function_arguments);
tx__sccp__cr__data__len.decode_text(function_arguments);
expect__compl__l3__success.decode_text(function_arguments);
cn__nr.decode_text(function_arguments);
rab__rel__cause.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TestHdlrParams(");
imsi__suffix.log();
TTCN_Logger::log_event_str(", ");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
expect__separate__sccp__cr.log();
TTCN_Logger::log_event_str(", ");
tx__sccp__cr__data__len.log();
TTCN_Logger::log_event_str(", ");
expect__compl__l3__success.log();
TTCN_Logger::log_event_str(", ");
cn__nr.log();
TTCN_Logger::log_event_str(", ");
rab__rel__cause.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TestHdlrParams(imsi__suffix, ps__domain, expect__separate__sccp__cr, tx__sccp__cr__data__len, expect__compl__l3__success, cn__nr, rab__rel__cause);
TTCN_Runtime::function_finished("f_TestHdlrParams");
return TRUE;
} else if (!strcmp(function_name, "IuhRanapCreateCallback")) {
BITSTRING context__id;
RUA__IEs::CN__DomainIndicator domain;
CHARSTRING id;
context__id.decode_text(function_arguments);
domain.decode_text(function_arguments);
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function IuhRanapCreateCallback(");
context__id.log();
TTCN_Logger::log_event_str(", ");
domain.log();
TTCN_Logger::log_event_str(", ");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
IuhRanapCreateCallback(context__id, domain, id);
TTCN_Runtime::function_finished("IuhRanapCreateCallback");
return TRUE;
} else if (!strcmp(function_name, "IuhRanapUnitdataCallback")) {
RANAP__PDU__Descriptions::RANAP__PDU ranap;
ranap.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function IuhRanapUnitdataCallback(");
ranap.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
IuhRanapUnitdataCallback(ranap);
TTCN_Runtime::function_finished("IuhRanapUnitdataCallback");
return TRUE;
} else if (!strcmp(function_name, "f_start_handler_create")) {
ConnHdlr::TestHdlrParams pars;
pars.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_start_handler_create(");
pars.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__start__handler__create(pars);
TTCN_Runtime::function_finished("f_start_handler_create");
return TRUE;
} else if (!strcmp(function_name, "f_start_handler_run")) {
COMPONENT vc__conn;
ConnHdlr::void__fn fn;
ConnHdlr::TestHdlrParams pars;
vc__conn.decode_text(function_arguments);
fn.decode_text(function_arguments);
pars.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_start_handler_run(");
vc__conn.log();
TTCN_Logger::log_event_str(", ");
fn.log();
TTCN_Logger::log_event_str(", ");
pars.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__start__handler__run(vc__conn, fn, pars);
TTCN_Runtime::function_finished("f_start_handler_run");
return TRUE;
} else if (!strcmp(function_name, "f_start_handler_with_pars")) {
ConnHdlr::void__fn fn;
ConnHdlr::TestHdlrParams_template pars;
fn.decode_text(function_arguments);
pars.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_start_handler_with_pars(");
fn.log();
TTCN_Logger::log_event_str(", ");
pars.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__start__handler__with__pars(fn, pars);
TTCN_Runtime::function_finished("f_start_handler_with_pars");
return TRUE;
} else if (!strcmp(function_name, "f_ConnHdlrList_all_done")) {
ConnHdlr::ConnHdlrList vc__conns;
vc__conns.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ConnHdlrList_all_done(");
vc__conns.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ConnHdlrList__all__done(vc__conns);
TTCN_Runtime::function_finished("f_ConnHdlrList_all_done");
return TRUE;
} else if (!strcmp(function_name, "f_hnbap_hnb_register")) {
INTEGER hnb__idx;
BOOLEAN expect__reject;
hnb__idx.decode_text(function_arguments);
expect__reject.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_hnbap_hnb_register(");
hnb__idx.log();
TTCN_Logger::log_event_str(", ");
expect__reject.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__hnbap__hnb__register(hnb__idx, expect__reject);
TTCN_Runtime::function_finished("f_hnbap_hnb_register");
return TRUE;
} else if (!strcmp(function_name, "f_hnbap_ue_register")) {
INTEGER hnb__idx;
HNBAP__IEs::UE__Identity_template ue__id;
BOOLEAN expect__reject;
hnb__idx.decode_text(function_arguments);
ue__id.decode_text(function_arguments);
expect__reject.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_hnbap_ue_register(");
hnb__idx.log();
TTCN_Logger::log_event_str(", ");
ue__id.log();
TTCN_Logger::log_event_str(", ");
expect__reject.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__hnbap__ue__register(hnb__idx, ue__id, expect__reject);
TTCN_Runtime::function_finished("f_hnbap_ue_register");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_hnb_init")) {
INTEGER hnb__start;
INTEGER hnb__count;
Osmocom__CTRL__Functions::CounterNameVals counternames;
hnb__start.decode_text(function_arguments);
hnb__count.decode_text(function_arguments);
counternames.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_init(");
hnb__start.log();
TTCN_Logger::log_event_str(", ");
hnb__count.log();
TTCN_Logger::log_event_str(", ");
counternames.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ctrs__hnb__init(hnb__start, hnb__count, counternames);
TTCN_Runtime::function_finished("f_ctrs_hnb_init");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_hnb_verify")) {
TTCN_Logger::log_str(TTCN_Logger::PARALLEL_PTC, "Starting function f_ctrs_hnb_verify().");
TTCN_Runtime::function_started(function_arguments);
f__ctrs__hnb__verify();
TTCN_Runtime::function_finished("f_ctrs_hnb_verify");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_hnb_expect")) {
INTEGER hnb__nr;
CHARSTRING countername;
INTEGER val;
hnb__nr.decode_text(function_arguments);
countername.decode_text(function_arguments);
val.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_expect(");
hnb__nr.log();
TTCN_Logger::log_event_str(", ");
countername.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ctrs__hnb__expect(hnb__nr, countername, val);
TTCN_Runtime::function_finished("f_ctrs_hnb_expect");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_hnb_add")) {
INTEGER hnb__nr;
CHARSTRING countername;
INTEGER val;
hnb__nr.decode_text(function_arguments);
countername.decode_text(function_arguments);
val.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_add(");
hnb__nr.log();
TTCN_Logger::log_event_str(", ");
countername.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ctrs__hnb__add(hnb__nr, countername, val);
TTCN_Runtime::function_finished("f_ctrs_hnb_add");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_hnb_set_all")) {
INTEGER hnb__nr;
INTEGER val;
hnb__nr.decode_text(function_arguments);
val.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_hnb_set_all(");
hnb__nr.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ctrs__hnb__set__all(hnb__nr, val);
TTCN_Runtime::function_finished("f_ctrs_hnb_set_all");
return TRUE;
} else if (!strcmp(function_name, "f_tc_initial_ue")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_initial_ue(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__initial__ue(id);
TTCN_Runtime::function_finished("f_tc_initial_ue");
return TRUE;
} else if (!strcmp(function_name, "f_tc_rab_assignment")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_assignment(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__rab__assignment(id);
TTCN_Runtime::function_finished("f_tc_rab_assignment");
return TRUE;
} else if (!strcmp(function_name, "f_tc_rab_assignment_concurrent")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_assignment_concurrent(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__rab__assignment__concurrent(id);
TTCN_Runtime::function_finished("f_tc_rab_assignment_concurrent");
return TRUE;
} else if (!strcmp(function_name, "f_tc_rab_assign_fail")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_assign_fail(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__rab__assign__fail(id);
TTCN_Runtime::function_finished("f_tc_rab_assign_fail");
return TRUE;
} else if (!strcmp(function_name, "f_tc_rab_release")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_release(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__rab__release(id);
TTCN_Runtime::function_finished("f_tc_rab_release");
return TRUE;
} else if (!strcmp(function_name, "f_tc_rab_assign_mgcp_to")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rab_assign_mgcp_to(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__rab__assign__mgcp__to(id);
TTCN_Runtime::function_finished("f_tc_rab_assign_mgcp_to");
return TRUE;
} else if (!strcmp(function_name, "f_tc_ranap_bidir")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ranap_bidir(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__ranap__bidir(id);
TTCN_Runtime::function_finished("f_tc_ranap_bidir");
return TRUE;
} else if (!strcmp(function_name, "f_tc_ranap_mo_disconnect")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ranap_mo_disconnect(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__ranap__mo__disconnect(id);
TTCN_Runtime::function_finished("f_tc_ranap_mo_disconnect");
return TRUE;
} else if (!strcmp(function_name, "f_tc_ranap_creq_cref_ConnHdlr")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ranap_creq_cref_ConnHdlr(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__ranap__creq__cref__ConnHdlr(id);
TTCN_Runtime::function_finished("f_tc_ranap_creq_cref_ConnHdlr");
return TRUE;
} else if (!strcmp(function_name, "f_tc_ranap_creq_cref")) {
INTEGER imsi__suffix;
BOOLEAN ps__domain;
imsi__suffix.decode_text(function_arguments);
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ranap_creq_cref(");
imsi__suffix.log();
TTCN_Logger::log_event_str(", ");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__ranap__creq__cref(imsi__suffix, ps__domain);
TTCN_Runtime::function_finished("f_tc_ranap_creq_cref");
return TRUE;
} else if (!strcmp(function_name, "f_tc_rua_disconnect_during_sccp_cr_cc")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rua_disconnect_during_sccp_cr_cc(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__rua__disconnect__during__sccp__cr__cc(id);
TTCN_Runtime::function_finished("f_tc_rua_disconnect_during_sccp_cr_cc");
return TRUE;
} else if (!strcmp(function_name, "f_TC_rua_disconnect_during_sccp_cr_cc")) {
BOOLEAN is__ps;
is__ps.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_rua_disconnect_during_sccp_cr_cc(");
is__ps.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__rua__disconnect__during__sccp__cr__cc(is__ps);
TTCN_Runtime::function_finished("f_TC_rua_disconnect_during_sccp_cr_cc");
return TRUE;
} else if (!strcmp(function_name, "f_tc_cs_iu_release_req_rua_disconnect")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_cs_iu_release_req_rua_disconnect(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__cs__iu__release__req__rua__disconnect(id);
TTCN_Runtime::function_finished("f_tc_cs_iu_release_req_rua_disconnect");
return TRUE;
} else if (!strcmp(function_name, "f_tc_ps_iu_release_req_rua_disconnect")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ps_iu_release_req_rua_disconnect(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__ps__iu__release__req__rua__disconnect(id);
TTCN_Runtime::function_finished("f_tc_ps_iu_release_req_rua_disconnect");
return TRUE;
} else if (!strcmp(function_name, "f_tc_rua_dt_during_sccp_wait_cc")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_rua_dt_during_sccp_wait_cc(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__rua__dt__during__sccp__wait__cc(id);
TTCN_Runtime::function_finished("f_tc_rua_dt_during_sccp_wait_cc");
return TRUE;
} else if (!strcmp(function_name, "f_TC_rua_dt_during_sccp_wait_cc")) {
BOOLEAN is__ps;
is__ps.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_rua_dt_during_sccp_wait_cc(");
is__ps.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__rua__dt__during__sccp__wait__cc(is__ps);
TTCN_Runtime::function_finished("f_TC_rua_dt_during_sccp_wait_cc");
return TRUE;
} else if (!strcmp(function_name, "f_tc_ps_rab_assignment")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_ps_rab_assignment(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__ps__rab__assignment(id);
TTCN_Runtime::function_finished("f_tc_ps_rab_assignment");
return TRUE;
} else if (!strcmp(function_name, "f_ps_tc_rab_release")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ps_tc_rab_release(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ps__tc__rab__release(id);
TTCN_Runtime::function_finished("f_ps_tc_rab_release");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_cn_init")) {
BOOLEAN ps__domain;
INTEGER cn__count;
Osmocom__CTRL__Functions::CounterNameVals counternames;
ps__domain.decode_text(function_arguments);
cn__count.decode_text(function_arguments);
counternames.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_cn_init(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
cn__count.log();
TTCN_Logger::log_event_str(", ");
counternames.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ctrs__cn__init(ps__domain, cn__count, counternames);
TTCN_Runtime::function_finished("f_ctrs_cn_init");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_cn_verify")) {
TTCN_Logger::log_str(TTCN_Logger::PARALLEL_PTC, "Starting function f_ctrs_cn_verify().");
TTCN_Runtime::function_started(function_arguments);
f__ctrs__cn__verify();
TTCN_Runtime::function_finished("f_ctrs_cn_verify");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_cn_expect")) {
INTEGER cn__nr;
CHARSTRING countername;
INTEGER val;
cn__nr.decode_text(function_arguments);
countername.decode_text(function_arguments);
val.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_cn_expect(");
cn__nr.log();
TTCN_Logger::log_event_str(", ");
countername.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ctrs__cn__expect(cn__nr, countername, val);
TTCN_Runtime::function_finished("f_ctrs_cn_expect");
return TRUE;
} else if (!strcmp(function_name, "f_ctrs_cn_add")) {
INTEGER cn__nr;
CHARSTRING countername;
INTEGER val;
cn__nr.decode_text(function_arguments);
countername.decode_text(function_arguments);
val.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_ctrs_cn_add(");
cn__nr.log();
TTCN_Logger::log_event_str(", ");
countername.log();
TTCN_Logger::log_event_str(", ");
val.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__ctrs__cn__add(cn__nr, countername, val);
TTCN_Runtime::function_finished("f_ctrs_cn_add");
return TRUE;
} else if (!strcmp(function_name, "f_tc_cnpool_compl_l3")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_cnpool_compl_l3(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__cnpool__compl__l3(id);
TTCN_Runtime::function_finished("f_tc_cnpool_compl_l3");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_compl_l3")) {
BOOLEAN ps__domain;
OCTETSTRING nas__pdu;
INTEGER cn__nr;
CHARSTRING_template inc__countername;
BOOLEAN expect__compl__l3__success;
ps__domain.decode_text(function_arguments);
nas__pdu.decode_text(function_arguments);
cn__nr.decode_text(function_arguments);
inc__countername.decode_text(function_arguments);
expect__compl__l3__success.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_compl_l3(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
nas__pdu.log();
TTCN_Logger::log_event_str(", ");
cn__nr.log();
TTCN_Logger::log_event_str(", ");
inc__countername.log();
TTCN_Logger::log_event_str(", ");
expect__compl__l3__success.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__compl__l3(ps__domain, nas__pdu, cn__nr, inc__countername, expect__compl__l3__success);
TTCN_Runtime::function_finished("f_TC_cnpool_compl_l3");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_compl_l3_list")) {
BOOLEAN ps__domain;
ro__octetstring compl3;
Osmocom__Types::ro__integer cn__nrs;
CHARSTRING_template inc__countername;
BOOLEAN expect__compl__l3__success;
ps__domain.decode_text(function_arguments);
compl3.decode_text(function_arguments);
cn__nrs.decode_text(function_arguments);
inc__countername.decode_text(function_arguments);
expect__compl__l3__success.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_compl_l3_list(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
compl3.log();
TTCN_Logger::log_event_str(", ");
cn__nrs.log();
TTCN_Logger::log_event_str(", ");
inc__countername.log();
TTCN_Logger::log_event_str(", ");
expect__compl__l3__success.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__compl__l3__list(ps__domain, compl3, cn__nrs, inc__countername, expect__compl__l3__success);
TTCN_Runtime::function_finished("f_TC_cnpool_compl_l3_list");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_L3Compl_on_1_cnlink")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Compl_on_1_cnlink(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__L3Compl__on__1__cnlink(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_L3Compl_on_1_cnlink");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_L3Complete_by_imsi_round_robin")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_by_imsi_round_robin(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__L3Complete__by__imsi__round__robin(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_L3Complete_by_imsi_round_robin");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_LU_by_tmsi_null_nri_N_round_robin")) {
BOOLEAN ps__domain;
INTEGER nri__val;
ps__domain.decode_text(function_arguments);
nri__val.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_LU_by_tmsi_null_nri_N_round_robin(");
ps__domain.log();
TTCN_Logger::log_event_str(", ");
nri__val.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__LU__by__tmsi__null__nri__N__round__robin(ps__domain, nri__val);
TTCN_Runtime::function_finished("f_TC_cnpool_LU_by_tmsi_null_nri_N_round_robin");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_L3Complete_by_tmsi_unassigned_nri_round_robin")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_by_tmsi_unassigned_nri_round_robin(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__L3Complete__by__tmsi__unassigned__nri__round__robin(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_L3Complete_by_tmsi_unassigned_nri_round_robin");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__L3Complete__by__tmsi__valid__nri__msc__not__connected__round__robin(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_L3Complete_by_tmsi_valid_nri_msc_not_connected_round_robin");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_L3Complete_valid_nri_1")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_valid_nri_1(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__L3Complete__valid__nri__1(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_L3Complete_valid_nri_1");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_L3Complete_valid_nri_2")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Complete_valid_nri_2(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__L3Complete__valid__nri__2(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_L3Complete_valid_nri_2");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_nri_from_other_PLMN")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_nri_from_other_PLMN(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__nri__from__other__PLMN(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_nri_from_other_PLMN");
return TRUE;
} else if (!strcmp(function_name, "f_tc_mscpool_paging_imsi")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_mscpool_paging_imsi(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__mscpool__paging__imsi(id);
TTCN_Runtime::function_finished("f_tc_mscpool_paging_imsi");
return TRUE;
} else if (!strcmp(function_name, "f_tc_mscpool_paging_tmsi")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_mscpool_paging_tmsi(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__mscpool__paging__tmsi(id);
TTCN_Runtime::function_finished("f_tc_mscpool_paging_tmsi");
return TRUE;
} else if (!strcmp(function_name, "f_tc_mscpool_paging_imsi_lai_registered")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_mscpool_paging_imsi_lai_registered(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__mscpool__paging__imsi__lai__registered(id);
TTCN_Runtime::function_finished("f_tc_mscpool_paging_imsi_lai_registered");
return TRUE;
} else if (!strcmp(function_name, "f_tc_mscpool_paging_imsi_rai_registered")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_mscpool_paging_imsi_rai_registered(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__mscpool__paging__imsi__rai__registered(id);
TTCN_Runtime::function_finished("f_tc_mscpool_paging_imsi_rai_registered");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_sccp_n_pcstate_detaches_cnlink")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_sccp_n_pcstate_detaches_cnlink(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__sccp__n__pcstate__detaches__cnlink(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_sccp_n_pcstate_detaches_cnlink");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_sccp_n_pcstate_attaches_cnlink")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_sccp_n_pcstate_attaches_cnlink(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__sccp__n__pcstate__attaches__cnlink(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_sccp_n_pcstate_attaches_cnlink");
return TRUE;
} else if (!strcmp(function_name, "f_tc_apply_sccp")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_apply_sccp(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__apply__sccp(id);
TTCN_Runtime::function_finished("f_tc_apply_sccp");
return TRUE;
} else if (!strcmp(function_name, "f_tc_second_rab_assignment")) {
CHARSTRING id;
id.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_tc_second_rab_assignment(");
id.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__tc__second__rab__assignment(id);
TTCN_Runtime::function_finished("f_tc_second_rab_assignment");
return TRUE;
} else if (!strcmp(function_name, "f_TC_cnpool_L3Compl_no_cn")) {
BOOLEAN ps__domain;
ps__domain.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_cnpool_L3Compl_no_cn(");
ps__domain.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__cnpool__L3Compl__no__cn(ps__domain);
TTCN_Runtime::function_finished("f_TC_cnpool_L3Compl_no_cn");
return TRUE;
} else if (!strcmp(function_name, "f_TC_stat_stp_sctp_disconnected_UnitdataCallback")) {
RANAP__PDU__Descriptions::RANAP__PDU ranap;
ranap.decode_text(function_arguments);
TTCN_Logger::begin_event(TTCN_Logger::PARALLEL_PTC);
TTCN_Logger::log_event_str("Starting function f_TC_stat_stp_sctp_disconnected_UnitdataCallback(");
ranap.log();
TTCN_Logger::log_event_str(").");
TTCN_Logger::end_event();
TTCN_Runtime::function_started(function_arguments);
f__TC__stat__stp__sctp__disconnected__UnitdataCallback(ranap);
TTCN_Runtime::function_finished("f_TC_stat_stp_sctp_disconnected_UnitdataCallback");
return TRUE;
} else return FALSE;
}


} /* end of namespace */