2020-09-08 16:58:22 +00:00
|
|
|
module GBProxy_Tests {
|
|
|
|
|
|
|
|
/* Osmocom GBProxy test suite in TTCN-3
|
2021-01-16 11:52:30 +00:00
|
|
|
* (C) 2020-2021 Harald Welte <laforge@osmocom.org>
|
2020-09-08 16:58:22 +00:00
|
|
|
* (C) 2020 sysmocom - s.f.m.c. GmbH
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Author: Daniel Willmann <dwillmann@sysmocom.de>
|
|
|
|
|
|
|
|
* Released under the terms of GNU General Public License, Version 2 or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
|
|
|
|
|
|
|
import from General_Types all;
|
|
|
|
import from Osmocom_Types all;
|
2020-12-09 13:44:50 +00:00
|
|
|
import from Misc_Helpers all;
|
2020-09-08 16:58:22 +00:00
|
|
|
import from GSM_Types all;
|
|
|
|
import from Native_Functions all;
|
|
|
|
import from NS_Types all;
|
|
|
|
import from NS_Emulation all;
|
|
|
|
import from BSSGP_Types all;
|
|
|
|
import from BSSGP_Emulation all;
|
|
|
|
import from SCCPasp_Types all;
|
|
|
|
import from Osmocom_Gb_Types all;
|
|
|
|
|
|
|
|
import from MobileL3_CommonIE_Types all;
|
|
|
|
import from MobileL3_GMM_SM_Types all;
|
|
|
|
import from MobileL3_Types all;
|
|
|
|
import from L3_Templates all;
|
|
|
|
import from L3_Common all;
|
|
|
|
|
|
|
|
import from TELNETasp_PortType all;
|
|
|
|
import from Osmocom_VTY_Functions all;
|
2021-03-30 14:28:04 +00:00
|
|
|
import from Osmocom_CTRL_Adapter all;
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
import from LLC_Types all;
|
|
|
|
import from LLC_Templates all;
|
|
|
|
|
|
|
|
import from GSM_RR_Types all;
|
|
|
|
|
2020-11-15 18:44:04 +00:00
|
|
|
/* mcc_mnc is 24.008 10.5.5.15 encoded. 262 42 */
|
|
|
|
const BcdMccMnc c_mcc_mnc := '262F42'H;
|
|
|
|
|
2020-11-29 15:04:07 +00:00
|
|
|
/* 48.016 section 6.1.4.2: The default maximum information field size of 1600 octets shall be supported on the Gb interface */
|
|
|
|
const integer max_fr_info_size := 1600;
|
|
|
|
|
2020-09-08 16:58:22 +00:00
|
|
|
modulepar {
|
2021-03-30 14:28:04 +00:00
|
|
|
charstring mp_gbproxy_ip := "127.0.0.1";
|
|
|
|
integer mp_gbproxy_ctrl_port := 4263;
|
2021-01-15 18:59:15 +00:00
|
|
|
/* NRI bit-length. 0 for no pooling */
|
|
|
|
integer mp_nri_bitlength := 5;
|
|
|
|
roro_integer mp_sgsn_nri := {
|
|
|
|
{ 3 }, /* list of NRIs of first SGSN */
|
|
|
|
{ 4 } /* list of NRIs of second SGSN */
|
|
|
|
};
|
2020-12-08 07:29:09 +00:00
|
|
|
boolean mp_enable_bss_load_sharing := false;
|
2020-12-01 09:54:08 +00:00
|
|
|
/* SGSN NS configuration */
|
2020-11-15 18:44:04 +00:00
|
|
|
NSConfigurations mp_nsconfig_sgsn := {
|
2020-09-08 16:58:22 +00:00
|
|
|
{
|
|
|
|
nsei := 101,
|
|
|
|
role_sgsn := true,
|
2020-11-06 18:34:40 +00:00
|
|
|
handle_sns := false,
|
|
|
|
nsvc := {
|
|
|
|
{
|
|
|
|
provider := {
|
|
|
|
ip := {
|
|
|
|
address_family := AF_INET,
|
|
|
|
local_udp_port := 7777,
|
2021-01-18 11:03:53 +00:00
|
|
|
local_ip := "127.0.0.10",
|
2020-11-06 18:34:40 +00:00
|
|
|
remote_udp_port := 23000,
|
2021-01-17 21:04:36 +00:00
|
|
|
remote_ip := "127.0.0.1",
|
2021-01-18 17:52:49 +00:00
|
|
|
data_weight := 0,
|
2021-01-17 21:04:36 +00:00
|
|
|
signalling_weight := 1
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
nsvci := 101
|
2021-01-18 17:52:49 +00:00
|
|
|
}, {
|
|
|
|
provider := {
|
|
|
|
ip := {
|
|
|
|
address_family := AF_INET,
|
|
|
|
local_udp_port := 7770,
|
|
|
|
local_ip := "127.0.0.10",
|
|
|
|
remote_udp_port := 23000,
|
|
|
|
remote_ip := "127.0.0.1",
|
|
|
|
data_weight := 1,
|
|
|
|
signalling_weight := 0
|
|
|
|
}
|
|
|
|
},
|
|
|
|
nsvci := 201
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
2021-01-17 21:04:36 +00:00
|
|
|
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
2020-12-12 13:01:11 +00:00
|
|
|
}, {
|
|
|
|
nsei := 102,
|
|
|
|
role_sgsn := true,
|
|
|
|
handle_sns := false,
|
|
|
|
nsvc := {
|
|
|
|
{
|
|
|
|
provider := {
|
|
|
|
ip := {
|
|
|
|
address_family := AF_INET,
|
|
|
|
local_udp_port := 8888,
|
2021-01-18 11:03:53 +00:00
|
|
|
local_ip := "127.0.0.11",
|
2020-12-12 13:01:11 +00:00
|
|
|
remote_udp_port := 23000,
|
2021-01-17 21:04:36 +00:00
|
|
|
remote_ip := "127.0.0.1",
|
2021-01-18 17:52:49 +00:00
|
|
|
data_weight := 0,
|
2021-01-17 21:04:36 +00:00
|
|
|
signalling_weight := 1
|
2020-12-12 13:01:11 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
nsvci := 102
|
2021-01-18 17:52:49 +00:00
|
|
|
}, {
|
|
|
|
provider := {
|
|
|
|
ip := {
|
|
|
|
address_family := AF_INET,
|
|
|
|
local_udp_port := 8880,
|
|
|
|
local_ip := "127.0.0.11",
|
|
|
|
remote_udp_port := 23000,
|
|
|
|
remote_ip := "127.0.0.1",
|
|
|
|
data_weight := 1,
|
|
|
|
signalling_weight := 0
|
|
|
|
}
|
|
|
|
},
|
|
|
|
nsvci := 202
|
2020-12-12 13:01:11 +00:00
|
|
|
}
|
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
};
|
2020-12-01 09:54:08 +00:00
|
|
|
/* BSS NSEI start at 2000 + x
|
|
|
|
* NSVCI start from value of NSEI + 100
|
|
|
|
* UDP port is NSVCI * 10 */
|
2020-11-15 18:44:04 +00:00
|
|
|
NSConfigurations mp_nsconfig_pcu := {
|
2020-09-08 16:58:22 +00:00
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
nsei := 2001,
|
2020-09-08 16:58:22 +00:00
|
|
|
role_sgsn := false,
|
2021-04-01 15:38:51 +00:00
|
|
|
handle_sns := true,
|
2020-11-06 18:34:40 +00:00
|
|
|
nsvc := {
|
|
|
|
{
|
|
|
|
provider := {
|
|
|
|
ip := {
|
|
|
|
address_family := AF_INET,
|
|
|
|
local_udp_port := 21010,
|
2021-01-18 11:03:53 +00:00
|
|
|
local_ip := "127.0.1.1",
|
2020-11-06 18:34:40 +00:00
|
|
|
remote_udp_port := 23000,
|
2021-04-01 15:38:51 +00:00
|
|
|
remote_ip := "127.0.0.2",
|
2021-01-17 21:04:36 +00:00
|
|
|
data_weight := 1,
|
|
|
|
signalling_weight := 1
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
|
|
|
},
|
2020-12-01 09:54:08 +00:00
|
|
|
nsvci := 2101
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
},
|
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
nsei := 2002,
|
2020-09-08 16:58:22 +00:00
|
|
|
role_sgsn := false,
|
2021-04-01 15:38:51 +00:00
|
|
|
handle_sns := true,
|
2020-11-06 18:34:40 +00:00
|
|
|
nsvc := {
|
|
|
|
{
|
|
|
|
provider := {
|
|
|
|
ip := {
|
|
|
|
address_family := AF_INET,
|
2020-12-01 09:54:08 +00:00
|
|
|
local_udp_port := 21020,
|
2021-01-18 11:03:53 +00:00
|
|
|
local_ip := "127.0.2.1",
|
2020-11-06 18:34:40 +00:00
|
|
|
remote_udp_port := 23000,
|
2021-04-01 15:38:51 +00:00
|
|
|
remote_ip := "127.0.0.2",
|
2021-01-17 21:04:36 +00:00
|
|
|
data_weight := 1,
|
|
|
|
signalling_weight := 1
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
|
|
|
},
|
2020-12-01 09:54:08 +00:00
|
|
|
nsvci := 2102
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
},
|
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
nsei := 2003,
|
2020-09-08 16:58:22 +00:00
|
|
|
role_sgsn := false,
|
2021-04-01 15:38:51 +00:00
|
|
|
handle_sns := true,
|
2020-11-06 18:34:40 +00:00
|
|
|
nsvc := {
|
|
|
|
{
|
|
|
|
provider := {
|
|
|
|
ip := {
|
|
|
|
address_family := AF_INET,
|
2020-12-01 09:54:08 +00:00
|
|
|
local_udp_port := 21030,
|
2021-01-18 11:03:53 +00:00
|
|
|
local_ip := "127.0.3.1",
|
2020-11-06 18:34:40 +00:00
|
|
|
remote_udp_port := 23000,
|
2021-04-01 15:38:51 +00:00
|
|
|
remote_ip := "127.0.0.2",
|
2021-01-17 21:04:36 +00:00
|
|
|
data_weight := 1,
|
|
|
|
signalling_weight := 1
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
|
|
|
},
|
2020-12-01 09:54:08 +00:00
|
|
|
nsvci := 2103
|
2020-11-06 18:34:40 +00:00
|
|
|
}
|
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
};
|
2020-12-01 09:54:08 +00:00
|
|
|
/* BVCI are NSEI*10 + x
|
|
|
|
* The first NSE only has one BVC, the second one 2 and so on
|
|
|
|
* The Cell ID is BVCI + 10000
|
|
|
|
* LAC/RAC are configured in such a way that:
|
|
|
|
* LAC 13135 is present once in NSE(2001), twice in NSE(2002) and once in NSE(2003)
|
|
|
|
* LAC 13300 is present twice in NSE(2003)
|
|
|
|
* RAI 13135-1 is present in NSE(2002) and NSE(2003)
|
|
|
|
* RAI 13300-0 is present twice in NSE(2003)
|
|
|
|
*/
|
2020-11-15 18:44:04 +00:00
|
|
|
BssgpConfigs mp_gbconfigs := {
|
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
nsei := 2001,
|
2020-11-15 18:44:04 +00:00
|
|
|
sgsn_role := false,
|
|
|
|
bvc := {
|
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
bvci := 20011,
|
2020-11-15 18:44:04 +00:00
|
|
|
cell_id := {
|
|
|
|
ra_id := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := c_mcc_mnc,
|
|
|
|
lac := 13135
|
|
|
|
},
|
|
|
|
rac := 0
|
|
|
|
},
|
2020-12-01 09:54:08 +00:00
|
|
|
cell_id := 30011
|
2020-11-15 18:44:04 +00:00
|
|
|
},
|
|
|
|
depth := BSSGP_DECODE_DEPTH_BSSGP,
|
|
|
|
create_cb := refers(BSSGP_Emulation.DefaultCreateCallback)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2020-12-01 09:54:08 +00:00
|
|
|
nsei := 2002,
|
2020-11-15 18:44:04 +00:00
|
|
|
sgsn_role := false,
|
|
|
|
bvc := {
|
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
bvci := 20021,
|
2020-11-15 18:44:04 +00:00
|
|
|
cell_id := {
|
|
|
|
ra_id := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := c_mcc_mnc,
|
2020-11-22 20:46:48 +00:00
|
|
|
lac := 13135
|
2020-11-15 18:44:04 +00:00
|
|
|
},
|
2020-11-22 20:46:48 +00:00
|
|
|
rac := 1
|
2020-11-15 18:44:04 +00:00
|
|
|
},
|
2020-12-01 09:54:08 +00:00
|
|
|
cell_id := 30021
|
|
|
|
},
|
|
|
|
depth := BSSGP_DECODE_DEPTH_BSSGP,
|
|
|
|
create_cb := refers(BSSGP_Emulation.DefaultCreateCallback)
|
|
|
|
},
|
|
|
|
{
|
|
|
|
bvci := 20022,
|
|
|
|
cell_id := {
|
|
|
|
ra_id := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := c_mcc_mnc,
|
|
|
|
lac := 13135
|
|
|
|
},
|
|
|
|
rac := 2
|
|
|
|
},
|
|
|
|
cell_id := 30022
|
2020-11-15 18:44:04 +00:00
|
|
|
},
|
|
|
|
depth := BSSGP_DECODE_DEPTH_BSSGP,
|
|
|
|
create_cb := refers(BSSGP_Emulation.DefaultCreateCallback)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2020-12-01 09:54:08 +00:00
|
|
|
nsei := 2003,
|
2020-11-15 18:44:04 +00:00
|
|
|
sgsn_role := false,
|
|
|
|
bvc := {
|
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
bvci := 20031,
|
|
|
|
cell_id := {
|
|
|
|
ra_id := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := c_mcc_mnc,
|
|
|
|
lac := 13135
|
|
|
|
},
|
|
|
|
rac := 1
|
|
|
|
},
|
|
|
|
cell_id := 30031
|
|
|
|
},
|
|
|
|
depth := BSSGP_DECODE_DEPTH_BSSGP,
|
|
|
|
create_cb := refers(BSSGP_Emulation.DefaultCreateCallback)
|
|
|
|
},
|
|
|
|
{
|
|
|
|
bvci := 20032,
|
|
|
|
cell_id := {
|
|
|
|
ra_id := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := c_mcc_mnc,
|
|
|
|
lac := 13300
|
|
|
|
},
|
|
|
|
rac := 0
|
|
|
|
},
|
|
|
|
cell_id := 30032
|
|
|
|
},
|
|
|
|
depth := BSSGP_DECODE_DEPTH_BSSGP,
|
|
|
|
create_cb := refers(BSSGP_Emulation.DefaultCreateCallback)
|
|
|
|
},
|
|
|
|
{
|
|
|
|
bvci := 20033,
|
2020-11-15 18:44:04 +00:00
|
|
|
cell_id := {
|
|
|
|
ra_id := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := c_mcc_mnc,
|
|
|
|
lac := 13300
|
|
|
|
},
|
|
|
|
rac := 0
|
|
|
|
},
|
2020-12-01 09:54:08 +00:00
|
|
|
cell_id := 30033
|
2020-11-15 18:44:04 +00:00
|
|
|
},
|
|
|
|
depth := BSSGP_DECODE_DEPTH_BSSGP,
|
|
|
|
create_cb := refers(BSSGP_Emulation.DefaultCreateCallback)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
type record GbInstance {
|
|
|
|
NS_CT vc_NS,
|
|
|
|
BSSGP_CT vc_BSSGP,
|
2020-11-17 17:32:29 +00:00
|
|
|
BSSGP_BVC_CTs vc_BSSGP_BVC,
|
2020-09-08 16:58:22 +00:00
|
|
|
BssgpConfig cfg
|
|
|
|
};
|
2020-11-17 17:32:29 +00:00
|
|
|
type record of BSSGP_BVC_CT BSSGP_BVC_CTs
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
const integer NUM_PCU := 3;
|
2020-11-15 18:44:04 +00:00
|
|
|
type record of GbInstance GbInstances;
|
|
|
|
type record of BssgpConfig BssgpConfigs;
|
|
|
|
type record of NSConfiguration NSConfigurations;
|
|
|
|
type record of BssgpCellId BssgpCellIds;
|
2020-09-08 16:58:22 +00:00
|
|
|
|
2021-03-30 11:19:56 +00:00
|
|
|
/* you cannot simply change this to any larger number of SGSNs and expect all test
|
|
|
|
* cases to work. This would have overly complicated the code. Check below for
|
|
|
|
* tests that use interleave on SGSN_MGMT.receive() for each SGSN NSEI for example */
|
2020-12-12 13:01:11 +00:00
|
|
|
const integer NUM_SGSN := 2;
|
2020-09-08 16:58:22 +00:00
|
|
|
|
2021-03-30 14:28:04 +00:00
|
|
|
type component test_CT extends CTRL_Adapter_CT {
|
2020-11-15 18:44:04 +00:00
|
|
|
var GbInstances g_pcu;
|
|
|
|
var GbInstances g_sgsn;
|
2020-09-08 16:58:22 +00:00
|
|
|
|
2021-05-28 13:05:41 +00:00
|
|
|
port NS_CTRL_PT NS_CTRL;
|
|
|
|
|
2020-09-08 16:58:22 +00:00
|
|
|
port BSSGP_CT_PROC_PT PROC;
|
|
|
|
|
2020-11-15 22:25:55 +00:00
|
|
|
port BSSGP_BVC_MGMT_PT SGSN_MGMT;
|
|
|
|
port BSSGP_BVC_MGMT_PT PCU_MGMT;
|
|
|
|
|
2020-09-08 16:58:22 +00:00
|
|
|
port TELNETasp_PT GBPVTY;
|
|
|
|
|
|
|
|
var boolean g_initialized := false;
|
|
|
|
var boolean g_use_echo := false;
|
2020-11-27 18:11:56 +00:00
|
|
|
|
|
|
|
var ro_integer g_roi := {};
|
2021-01-21 17:11:12 +00:00
|
|
|
var roro_integer g_roroi := {};
|
2020-12-09 13:33:18 +00:00
|
|
|
timer g_Tguard;
|
2020-09-08 16:58:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
type component BSSGP_ConnHdlr {
|
2020-11-17 18:21:00 +00:00
|
|
|
/* array of per-BVC ports on the PCU side */
|
2020-12-09 11:32:32 +00:00
|
|
|
port BSSGP_PT PCU_PTP[NUM_PCU];
|
2020-09-08 16:58:22 +00:00
|
|
|
port BSSGP_PT PCU_SIG[NUM_PCU];
|
|
|
|
port BSSGP_PROC_PT PCU_PROC[NUM_PCU];
|
2020-11-17 18:21:00 +00:00
|
|
|
/* component reference to the component to which we're currently connected */
|
|
|
|
var BSSGP_BVC_CT pcu_ct[NUM_PCU];
|
2020-11-22 20:46:48 +00:00
|
|
|
/* BSSGP BVC configuration of the component to which we're currently connected */
|
|
|
|
var BssgpBvcConfig pcu_bvc_cfg[NUM_PCU];
|
2020-11-17 18:21:00 +00:00
|
|
|
|
|
|
|
/* array of per-BVC ports on the SGSN side */
|
2020-12-09 11:32:32 +00:00
|
|
|
port BSSGP_PT SGSN_PTP[NUM_SGSN];
|
2020-09-08 16:58:22 +00:00
|
|
|
port BSSGP_PT SGSN_SIG[NUM_SGSN];
|
|
|
|
port BSSGP_PROC_PT SGSN_PROC[NUM_SGSN];
|
2020-11-17 18:21:00 +00:00
|
|
|
/* component reference to the component to which we're currently connected */
|
|
|
|
var BSSGP_BVC_CT sgsn_ct[NUM_PCU];
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
var BSSGP_ConnHdlrPars g_pars;
|
|
|
|
timer g_Tguard;
|
|
|
|
var LLC_Entities llc;
|
2020-11-22 20:46:48 +00:00
|
|
|
|
|
|
|
var ro_integer g_roi := {};
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type record SGSN_ConnHdlrNetworkPars {
|
|
|
|
boolean expect_ptmsi,
|
|
|
|
boolean expect_auth,
|
|
|
|
boolean expect_ciph
|
|
|
|
};
|
|
|
|
|
|
|
|
type record BSSGP_ConnHdlrPars {
|
|
|
|
/* IMEI of the simulated ME */
|
|
|
|
hexstring imei,
|
|
|
|
/* IMSI of the simulated MS */
|
|
|
|
hexstring imsi,
|
|
|
|
/* MSISDN of the simulated MS (probably unused) */
|
|
|
|
hexstring msisdn,
|
|
|
|
/* P-TMSI allocated to the simulated MS */
|
|
|
|
OCT4 p_tmsi optional,
|
|
|
|
OCT3 p_tmsi_sig optional,
|
|
|
|
/* TLLI of the simulated MS */
|
|
|
|
OCT4 tlli,
|
|
|
|
OCT4 tlli_old optional,
|
|
|
|
RoutingAreaIdentificationV ra optional,
|
2020-11-17 17:20:00 +00:00
|
|
|
GbInstances pcu,
|
2020-11-17 18:21:00 +00:00
|
|
|
GbInstances sgsn,
|
2021-01-16 10:07:01 +00:00
|
|
|
/* The SGSN index to be used within the test */
|
|
|
|
integer sgsn_idx,
|
2020-09-08 16:58:22 +00:00
|
|
|
float t_guard
|
|
|
|
};
|
|
|
|
|
2021-01-17 12:48:13 +00:00
|
|
|
private function get_bvc_idx_for_bvci(GbInstance gbi, BssgpBvci bvci) return integer
|
|
|
|
{
|
|
|
|
var integer i;
|
|
|
|
|
|
|
|
for (i := 0; i < lengthof(gbi.cfg.bvc); i := i + 1) {
|
|
|
|
if (gbi.cfg.bvc[i].bvci == bvci) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(fail, "Could not find BVC Index for BVCI ", bvci);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2020-09-08 16:58:22 +00:00
|
|
|
private function f_cellid_to_RAI(in BssgpCellId cell_id) return RoutingAreaIdentificationV {
|
|
|
|
/* mcc_mnc is encoded as of 24.008 10.5.5.15 */
|
|
|
|
var BcdMccMnc mcc_mnc := cell_id.ra_id.lai.mcc_mnc;
|
|
|
|
|
|
|
|
var RoutingAreaIdentificationV ret := {
|
|
|
|
mccDigit1 := mcc_mnc[0],
|
|
|
|
mccDigit2 := mcc_mnc[1],
|
|
|
|
mccDigit3 := mcc_mnc[2],
|
|
|
|
mncDigit3 := mcc_mnc[3],
|
|
|
|
mncDigit1 := mcc_mnc[4],
|
|
|
|
mncDigit2 := mcc_mnc[5],
|
|
|
|
lac := int2oct(cell_id.ra_id.lai.lac, 16),
|
|
|
|
rac := int2oct(cell_id.ra_id.rac, 8)
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
2020-12-02 17:50:52 +00:00
|
|
|
private function f_fix_create_cb(inout BssgpConfig cfg)
|
|
|
|
{
|
|
|
|
for (var integer i := 0; i < lengthof(cfg.bvc); i := i + 1) {
|
|
|
|
if (not isbound(cfg.bvc[i].create_cb)) {
|
|
|
|
cfg.bvc[i].create_cb := refers(BSSGP_Emulation.DefaultCreateCallback)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-08 16:58:22 +00:00
|
|
|
private function f_init_gb_pcu(inout GbInstance gb, charstring id, integer offset) runs on test_CT {
|
2020-11-16 15:45:05 +00:00
|
|
|
var charstring ns_id := id & "-NS(PCU[" & int2str(offset) & "])";
|
|
|
|
var charstring bssgp_id := id & "-BSSGP(PCU[" & int2str(offset) & "])";
|
|
|
|
gb.vc_NS := NS_CT.create(ns_id);
|
|
|
|
gb.vc_BSSGP := BSSGP_CT.create(bssgp_id);
|
2020-09-08 16:58:22 +00:00
|
|
|
/* connect lower end of BSSGP emulation with NS upper port */
|
|
|
|
connect(gb.vc_BSSGP:BSCP, gb.vc_NS:NS_SP);
|
|
|
|
|
2020-11-16 15:45:05 +00:00
|
|
|
gb.vc_NS.start(NSStart(mp_nsconfig_pcu[offset], ns_id));
|
|
|
|
gb.vc_BSSGP.start(BssgpStart(gb.cfg, bssgp_id));
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(gb.cfg.bvc); i := i + 1) {
|
2020-12-12 13:01:11 +00:00
|
|
|
/* obtain the component reference of the BSSGP_BVC_CT for each PTP BVC */
|
2020-09-08 16:58:22 +00:00
|
|
|
connect(self:PROC, gb.vc_BSSGP:PROC);
|
|
|
|
gb.vc_BSSGP_BVC[i] := f_bssgp_get_bvci_ct(gb.cfg.bvc[i].bvci, PROC);
|
|
|
|
disconnect(self:PROC, gb.vc_BSSGP:PROC);
|
2020-12-12 13:01:11 +00:00
|
|
|
/* connect all of the per-BVC MGMT ports to our PCU_MGMT port (1:N) */
|
2020-11-15 22:25:55 +00:00
|
|
|
connect(self:PCU_MGMT, gb.vc_BSSGP_BVC[i]:MGMT);
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
2020-12-12 13:01:11 +00:00
|
|
|
/* connect all of the BSSGP/NSE global MGMT port to our PCU_MGMT port (1:N) */
|
2020-11-27 18:11:56 +00:00
|
|
|
connect(self:PCU_MGMT, gb.vc_BSSGP:MGMT);
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private function f_init_gb_sgsn(inout GbInstance gb, charstring id, integer offset) runs on test_CT {
|
2020-11-16 15:45:05 +00:00
|
|
|
var charstring ns_id := id & "-NS(SGSN[" & int2str(offset) & "])";
|
|
|
|
var charstring bssgp_id := id & "-BSSGP(SGSN[" & int2str(offset) & "])";
|
|
|
|
gb.vc_NS := NS_CT.create(ns_id);
|
|
|
|
gb.vc_BSSGP := BSSGP_CT.create(bssgp_id);
|
2020-09-08 16:58:22 +00:00
|
|
|
/* connect lower end of BSSGP emulation with NS upper port */
|
|
|
|
connect(gb.vc_BSSGP:BSCP, gb.vc_NS:NS_SP);
|
|
|
|
|
2020-11-16 15:45:05 +00:00
|
|
|
gb.vc_NS.start(NSStart(mp_nsconfig_sgsn[offset], ns_id));
|
|
|
|
gb.vc_BSSGP.start(BssgpStart(gb.cfg, bssgp_id));
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(gb.cfg.bvc); i := i + 1) {
|
2020-12-12 13:01:11 +00:00
|
|
|
/* obtain the component reference of the BSSGP_BVC_CT for each PTP BVC */
|
2020-09-08 16:58:22 +00:00
|
|
|
connect(self:PROC, gb.vc_BSSGP:PROC);
|
|
|
|
gb.vc_BSSGP_BVC[i] := f_bssgp_get_bvci_ct(gb.cfg.bvc[i].bvci, PROC);
|
|
|
|
disconnect(self:PROC, gb.vc_BSSGP:PROC);
|
2020-12-12 13:01:11 +00:00
|
|
|
/* connect all of the per-BVC MGMT ports to our SGSN_MGMT port (1:N) */
|
2020-11-15 22:25:55 +00:00
|
|
|
connect(self:SGSN_MGMT, gb.vc_BSSGP_BVC[i]:MGMT);
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
2020-12-12 13:01:11 +00:00
|
|
|
/* connect all of the BSSGP/NSE global MGMT port to our SGSN_MGMT port (1:N) */
|
2020-11-27 18:11:56 +00:00
|
|
|
connect(self:SGSN_MGMT, gb.vc_BSSGP:MGMT);
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-12-09 13:44:50 +00:00
|
|
|
private function f_destroy_gb(inout GbInstance gb) runs on test_CT {
|
|
|
|
gb.vc_NS.stop;
|
|
|
|
gb.vc_BSSGP.stop;
|
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(gb.cfg.bvc); i := i + 1) {
|
|
|
|
gb.vc_BSSGP_BVC[i].stop;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-08 16:58:22 +00:00
|
|
|
private function f_init_vty() runs on test_CT {
|
|
|
|
map(self:GBPVTY, system:GBPVTY);
|
|
|
|
f_vty_set_prompts(GBPVTY);
|
|
|
|
f_vty_transceive(GBPVTY, "enable");
|
|
|
|
}
|
|
|
|
|
2020-12-12 13:01:11 +00:00
|
|
|
/* count the number of unblocked BVCI for each SGSN NSE */
|
|
|
|
private altstep as_count_unblocked4nse(integer sgsn_idx, inout roro_integer bvci_unblocked)
|
|
|
|
runs on test_CT {
|
|
|
|
var BssgpStatusIndication bsi;
|
|
|
|
[] SGSN_MGMT.receive(BssgpStatusIndication:{g_sgsn[sgsn_idx].cfg.nsei, ?, BVC_S_UNBLOCKED}) -> value bsi {
|
|
|
|
bvci_unblocked[sgsn_idx] := bvci_unblocked[sgsn_idx] & { bsi.bvci };
|
|
|
|
/* 'repeat' until sufficient number of BVC-rest has been received on all SGSNs */
|
|
|
|
for (var integer i := 0; i < lengthof(bvci_unblocked); i := i+1) {
|
|
|
|
if (lengthof(bvci_unblocked[i]) < lengthof(g_sgsn[i].cfg.bvc)) {
|
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-30 14:28:04 +00:00
|
|
|
private template (value) charstring ts_pcu_bvc_fsm_id(uint16_t nsei, uint16_t bvci) :=
|
|
|
|
"NSE" & f_int2str(nsei, 5) & "-BVC" & f_int2str(bvci, 5);
|
|
|
|
|
|
|
|
function f_bvc_fsm_ensure_state(uint16_t nsei, uint16_t bvci, template (present) charstring exp)
|
|
|
|
runs on CTRL_Adapter_CT {
|
|
|
|
f_ctrl_get_exp_inst_state(IPA_CTRL, "BSSGP-BVC", ts_pcu_bvc_fsm_id(nsei, bvci), exp);
|
|
|
|
}
|
|
|
|
|
2020-12-09 13:33:18 +00:00
|
|
|
function f_init(float t_guard := 30.0) runs on test_CT {
|
2020-12-12 13:01:11 +00:00
|
|
|
var roro_integer bvci_unblocked;
|
2020-11-15 22:25:55 +00:00
|
|
|
var BssgpStatusIndication bsi;
|
2020-09-08 16:58:22 +00:00
|
|
|
var integer i;
|
|
|
|
|
|
|
|
if (g_initialized == true) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
g_initialized := true;
|
|
|
|
|
2020-12-09 13:33:18 +00:00
|
|
|
g_Tguard.start(t_guard);
|
|
|
|
activate(as_gTguard(g_Tguard));
|
|
|
|
|
2021-03-30 14:28:04 +00:00
|
|
|
f_ipa_ctrl_start_client(mp_gbproxy_ip, mp_gbproxy_ctrl_port);
|
|
|
|
|
2020-12-12 13:01:11 +00:00
|
|
|
var BssgpBvcConfigs bvcs := { };
|
2020-11-15 18:44:04 +00:00
|
|
|
for (i := 0; i < lengthof(mp_gbconfigs); i := i+1) {
|
|
|
|
g_pcu[i].cfg := mp_gbconfigs[i];
|
2020-12-02 17:50:52 +00:00
|
|
|
/* make sure all have a proper crate_cb, which cannot be specified in config file */
|
|
|
|
f_fix_create_cb(g_pcu[i].cfg);
|
2020-11-15 18:44:04 +00:00
|
|
|
/* concatenate all the PCU-side BVCs for the SGSN side */
|
2020-12-12 13:01:11 +00:00
|
|
|
bvcs := bvcs & g_pcu[i].cfg.bvc;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
|
|
|
g_sgsn[i].cfg := {
|
|
|
|
nsei := mp_nsconfig_sgsn[i].nsei,
|
|
|
|
sgsn_role := true,
|
|
|
|
bvc := bvcs
|
|
|
|
}
|
2020-11-15 18:44:04 +00:00
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
f_init_vty();
|
2020-11-15 18:44:04 +00:00
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
2020-11-18 12:26:57 +00:00
|
|
|
f_vty_transceive(GBPVTY, "nsvc nsei " & int2str(g_sgsn[i].cfg.nsei) & " force-unconfigured");
|
2020-12-04 13:14:38 +00:00
|
|
|
}
|
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_pcu); i := i+1) {
|
|
|
|
f_vty_transceive(GBPVTY, "nsvc nsei " & int2str(g_pcu[i].cfg.nsei) & " force-unconfigured");
|
|
|
|
f_vty_transceive(GBPVTY, "delete-gbproxy-peer " & int2str(g_pcu[i].cfg.nsei) & " only-bvc");
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
2020-11-17 17:05:13 +00:00
|
|
|
f_init_gb_sgsn(g_sgsn[i], "GbProxy_Test", i);
|
2020-11-15 18:44:04 +00:00
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
f_sleep(4.0);
|
2020-11-15 18:44:04 +00:00
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_pcu); i := i+1) {
|
2020-11-16 15:45:05 +00:00
|
|
|
f_init_gb_pcu(g_pcu[i], "GbProxy_Test", i);
|
2020-11-15 18:44:04 +00:00
|
|
|
}
|
2020-11-15 22:25:55 +00:00
|
|
|
|
2020-12-12 13:01:11 +00:00
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
|
|
|
bvci_unblocked[i] := {};
|
|
|
|
}
|
|
|
|
|
2020-11-15 22:25:55 +00:00
|
|
|
/* wait until all BVC are unblocked on both sides */
|
2020-11-17 18:22:58 +00:00
|
|
|
timer T := 15.0;
|
2020-11-15 22:25:55 +00:00
|
|
|
T.start;
|
|
|
|
alt {
|
2020-12-12 13:01:11 +00:00
|
|
|
/* TODO: We need to add more lines if NUM_SGSN increases. Activating default altsteps
|
|
|
|
* unfortunately doesn't work as we want to access the local variable bvci_unblocked. */
|
|
|
|
[] as_count_unblocked4nse(0, bvci_unblocked);
|
|
|
|
[lengthof(g_sgsn) > 1] as_count_unblocked4nse(1, bvci_unblocked);
|
2020-11-15 22:25:55 +00:00
|
|
|
[] SGSN_MGMT.receive(BssgpStatusIndication:{*, ?, ?}) {
|
|
|
|
repeat;
|
|
|
|
}
|
2020-11-26 19:56:09 +00:00
|
|
|
[] SGSN_MGMT.receive(BssgpResetIndication:?) {
|
|
|
|
repeat;
|
|
|
|
}
|
2020-11-15 22:25:55 +00:00
|
|
|
[] SGSN_MGMT.receive {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, "Received unexpected message on SGSN_MGMT");
|
2020-11-15 22:25:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[] PCU_MGMT.receive(BssgpStatusIndication:{*, ?, BVC_S_UNBLOCKED}) -> value bsi {
|
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
[] PCU_MGMT.receive(BssgpStatusIndication:{*, ?, ?}) {
|
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
[] PCU_MGMT.receive(BssgpResetIndication:{0}) {
|
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
[] PCU_MGMT.receive {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, "Received unexpected message on PCU_MGMT");
|
2020-11-15 22:25:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
[] T.timeout {
|
2020-12-12 12:10:45 +00:00
|
|
|
setverdict(fail, "Timeout waiting for unblock of all BVCs on SGSN side; ",
|
2020-12-12 13:01:11 +00:00
|
|
|
"unblocked so far: ", bvci_unblocked);
|
2020-12-12 12:10:45 +00:00
|
|
|
/* don't stop here but print below analysis */
|
2020-11-15 22:25:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-12 13:01:11 +00:00
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
|
|
|
/* iterate over list and check all BVCI */
|
|
|
|
for (var integer j := 0; j < lengthof(g_sgsn[i].cfg.bvc); j := j+1) {
|
|
|
|
var BssgpBvci bvci := g_sgsn[i].cfg.bvc[j].bvci;
|
|
|
|
if (not ro_integer_contains(bvci_unblocked[i], bvci)) {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("SGSN ", i, " BVCI=", bvci, " was not unblocked during start-up"));
|
2020-12-12 13:01:11 +00:00
|
|
|
}
|
2020-11-15 22:25:55 +00:00
|
|
|
}
|
|
|
|
}
|
2020-12-09 13:33:18 +00:00
|
|
|
|
2021-03-30 14:28:04 +00:00
|
|
|
/* verify all SGSN-side BVC FSM in IUT are UNBLOCKED */
|
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
|
|
|
f_bvc_fsm_ensure_state(mp_nsconfig_sgsn[i].nsei, 0, "UNBLOCKED");
|
|
|
|
/* iterate over list and check all BVCI */
|
|
|
|
for (var integer j := 0; j < lengthof(g_sgsn[i].cfg.bvc); j := j+1) {
|
|
|
|
var BssgpBvci bvci := g_sgsn[i].cfg.bvc[j].bvci;
|
|
|
|
f_bvc_fsm_ensure_state(mp_nsconfig_sgsn[i].nsei, bvci, "UNBLOCKED");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* verify all PCU-side BVC FSM in IUT are UNBLOCKED */
|
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_pcu); i := i+1) {
|
|
|
|
f_bvc_fsm_ensure_state(mp_nsconfig_pcu[i].nsei, 0, "UNBLOCKED");
|
|
|
|
/* iterate over list and check all BVCI */
|
|
|
|
for (var integer j := 0; j < lengthof(g_pcu[i].cfg.bvc); j := j+1) {
|
|
|
|
var BssgpBvci bvci := g_pcu[i].cfg.bvc[j].bvci;
|
|
|
|
f_bvc_fsm_ensure_state(mp_nsconfig_pcu[i].nsei, bvci, "UNBLOCKED");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-09 13:33:18 +00:00
|
|
|
/* re-start guard timer after all BVCs are up, so it only counts the actual test case */
|
|
|
|
g_Tguard.start(t_guard);
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function f_cleanup() runs on test_CT {
|
2020-12-09 13:44:50 +00:00
|
|
|
var integer i;
|
|
|
|
|
2021-01-08 00:32:51 +00:00
|
|
|
/* To avoid a dynamic test case error we need to prevent messages arriving on unconnected
|
|
|
|
* ports. Waiting here ensures that any messages "in flight" will be delivered to the port
|
|
|
|
* before the component is shutdown and disconnected. */
|
|
|
|
f_sleep(0.2);
|
|
|
|
|
2020-12-09 13:44:50 +00:00
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
|
|
|
f_destroy_gb(g_sgsn[i]);
|
|
|
|
}
|
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_pcu); i := i+1) {
|
|
|
|
f_destroy_gb(g_pcu[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
Misc_Helpers.f_shutdown(__BFILE__, __LINE__, pass);
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type function void_fn(charstring id) runs on BSSGP_ConnHdlr;
|
|
|
|
|
|
|
|
/* helper function to create, connect and start a BSSGP_ConnHdlr component */
|
2021-01-16 11:52:30 +00:00
|
|
|
function f_start_handler(void_fn fn, charstring id, integer imsi_suffix, float t_guard := 30.0,
|
|
|
|
integer sgsn_idx := 0, integer nri_idx := 0, boolean have_ptmsi := true)
|
2020-09-08 16:58:22 +00:00
|
|
|
runs on test_CT return BSSGP_ConnHdlr {
|
|
|
|
var BSSGP_ConnHdlr vc_conn;
|
2021-01-16 10:07:01 +00:00
|
|
|
var integer nri := mp_sgsn_nri[sgsn_idx][nri_idx];
|
2021-01-15 18:59:15 +00:00
|
|
|
var OCT4 p_tmsi := f_gen_tmsi(imsi_suffix, nri_v := nri, nri_bitlen := mp_nri_bitlength);
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
var BSSGP_ConnHdlrPars pars := {
|
|
|
|
imei := f_gen_imei(imsi_suffix),
|
|
|
|
imsi := f_gen_imsi(imsi_suffix),
|
|
|
|
msisdn := f_gen_msisdn(imsi_suffix),
|
2021-01-14 20:03:14 +00:00
|
|
|
p_tmsi := p_tmsi,
|
2020-09-08 16:58:22 +00:00
|
|
|
p_tmsi_sig := omit,
|
2021-01-14 20:03:14 +00:00
|
|
|
tlli := f_gprs_tlli_from_tmsi(p_tmsi, TLLI_LOCAL),
|
2020-09-08 16:58:22 +00:00
|
|
|
tlli_old := omit,
|
|
|
|
ra := omit,
|
2021-01-16 10:23:09 +00:00
|
|
|
pcu := g_pcu,
|
|
|
|
sgsn := g_sgsn,
|
2021-01-16 10:07:01 +00:00
|
|
|
sgsn_idx := sgsn_idx,
|
2020-09-08 16:58:22 +00:00
|
|
|
t_guard := t_guard
|
|
|
|
};
|
2021-01-16 11:52:30 +00:00
|
|
|
if (not have_ptmsi) {
|
|
|
|
pars.p_tmsi := omit;
|
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
vc_conn := BSSGP_ConnHdlr.create(id);
|
|
|
|
|
2021-01-17 10:09:49 +00:00
|
|
|
log("Starting ", id, " for SGSN[", sgsn_idx, "], NRI=", nri, ", P-TMSI=", pars.p_tmsi,
|
|
|
|
", TLLI=", pars.tlli, ", IMSI=", pars.imsi, " on component=", vc_conn);
|
2020-09-08 16:58:22 +00:00
|
|
|
vc_conn.start(f_handler_init(fn, id, pars));
|
|
|
|
return vc_conn;
|
|
|
|
}
|
|
|
|
|
2021-01-16 11:52:30 +00:00
|
|
|
function f_start_handlers(void_fn fn, charstring id, integer imsi_suffix, float t_guard := 30.0,
|
|
|
|
boolean have_ptmsi := true)
|
2021-01-16 10:07:01 +00:00
|
|
|
runs on test_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, nri_idx;
|
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx:=sgsn_idx+1) {
|
|
|
|
for (nri_idx := 0; nri_idx < lengthof(mp_sgsn_nri[sgsn_idx]); nri_idx:=nri_idx+1) {
|
|
|
|
var integer extd_imsi_suffix := 1000*sgsn_idx + 100*nri_idx;
|
|
|
|
var BSSGP_ConnHdlr vc_conn;
|
2021-01-16 11:52:30 +00:00
|
|
|
vc_conn := f_start_handler(fn, id, extd_imsi_suffix, t_guard, sgsn_idx, nri_idx,
|
|
|
|
have_ptmsi);
|
2021-01-16 10:07:01 +00:00
|
|
|
/* Idea: we could also run them in parallel ? */
|
|
|
|
vc_conn.done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-17 18:21:00 +00:00
|
|
|
/* Connect the PCU-side per-BVC ports (PCU/PCU_SIG/PCU_PROC) array slot 'port_idx' to specified per-BVC component */
|
2020-11-22 20:46:48 +00:00
|
|
|
private function f_connect_to_pcu_bvc(integer port_idx, integer nse_idx, integer bvc_idx)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
|
|
|
var BSSGP_BVC_CT bvc_ct := g_pars.pcu[nse_idx].vc_BSSGP_BVC[bvc_idx]
|
2020-12-09 11:32:32 +00:00
|
|
|
if (PCU_PTP[port_idx].checkstate("Connected")) {
|
2020-11-17 18:21:00 +00:00
|
|
|
/* unregister + disconnect from old BVC */
|
|
|
|
f_client_unregister(g_pars.imsi, PCU_PROC[port_idx]);
|
2020-12-09 11:32:32 +00:00
|
|
|
disconnect(self:PCU_PTP[port_idx], pcu_ct[port_idx]:BSSGP_SP);
|
2020-11-17 18:21:00 +00:00
|
|
|
disconnect(self:PCU_SIG[port_idx], pcu_ct[port_idx]:BSSGP_SP_SIG);
|
|
|
|
disconnect(self:PCU_PROC[port_idx], pcu_ct[port_idx]:BSSGP_PROC);
|
|
|
|
}
|
|
|
|
/* connect to new BVC and register us */
|
2020-12-09 11:32:32 +00:00
|
|
|
connect(self:PCU_PTP[port_idx], bvc_ct:BSSGP_SP);
|
2020-11-17 18:21:00 +00:00
|
|
|
connect(self:PCU_SIG[port_idx], bvc_ct:BSSGP_SP_SIG);
|
|
|
|
connect(self:PCU_PROC[port_idx], bvc_ct:BSSGP_PROC);
|
|
|
|
f_client_register(g_pars.imsi, g_pars.tlli, PCU_PROC[port_idx]);
|
|
|
|
pcu_ct[port_idx] := bvc_ct;
|
2020-11-22 20:46:48 +00:00
|
|
|
pcu_bvc_cfg[port_idx] := g_pars.pcu[nse_idx].cfg.bvc[bvc_idx];
|
2020-11-17 18:21:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Connect the SGSN-side per-BVC ports (SGSN/SGSN_SIG/SGSN_PROC) array slot 'port_idx' to specified per-BVC component */
|
|
|
|
private function f_connect_to_sgsn_bvc(integer port_idx, BSSGP_BVC_CT bvc_ct) runs on BSSGP_ConnHdlr {
|
2020-12-09 11:32:32 +00:00
|
|
|
if (SGSN_PTP[port_idx].checkstate("Connected")) {
|
2020-11-17 18:21:00 +00:00
|
|
|
/* unregister + disconnect from old BVC */
|
|
|
|
f_client_unregister(g_pars.imsi, SGSN_PROC[port_idx]);
|
2020-12-09 11:32:32 +00:00
|
|
|
disconnect(self:SGSN_PTP[port_idx], sgsn_ct[port_idx]:BSSGP_SP);
|
2020-11-17 18:21:00 +00:00
|
|
|
disconnect(self:SGSN_SIG[port_idx], sgsn_ct[port_idx]:BSSGP_SP_SIG);
|
|
|
|
disconnect(self:SGSN_PROC[port_idx], sgsn_ct[port_idx]:BSSGP_PROC);
|
|
|
|
}
|
|
|
|
/* connect to new BVC and register us */
|
2020-12-09 11:32:32 +00:00
|
|
|
connect(self:SGSN_PTP[port_idx], bvc_ct:BSSGP_SP);
|
2020-11-17 18:21:00 +00:00
|
|
|
connect(self:SGSN_SIG[port_idx], bvc_ct:BSSGP_SP_SIG);
|
|
|
|
connect(self:SGSN_PROC[port_idx], bvc_ct:BSSGP_PROC);
|
|
|
|
f_client_register(g_pars.imsi, g_pars.tlli, SGSN_PROC[port_idx]);
|
|
|
|
sgsn_ct[port_idx] := bvc_ct;
|
|
|
|
}
|
|
|
|
|
2020-12-09 13:33:18 +00:00
|
|
|
private altstep as_gTguard(timer Tguard) {
|
|
|
|
[] Tguard.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, "Tguard timeout");
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* first function called in every ConnHdlr */
|
|
|
|
private function f_handler_init(void_fn fn, charstring id, BSSGP_ConnHdlrPars pars)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
2020-11-15 19:02:59 +00:00
|
|
|
var integer i;
|
2020-09-08 16:58:22 +00:00
|
|
|
/* do some common stuff like setting up g_pars */
|
|
|
|
g_pars := pars;
|
|
|
|
|
|
|
|
llc := f_llc_create(false);
|
|
|
|
|
2020-11-17 18:21:00 +00:00
|
|
|
/* default connections on PCU side: First BVC of each NSE/PCU */
|
|
|
|
for (i := 0; i < lengthof(g_pars.pcu); i := i+1) {
|
2020-11-22 20:46:48 +00:00
|
|
|
f_connect_to_pcu_bvc(port_idx := i, nse_idx := i, bvc_idx := 0);
|
2020-11-15 19:02:59 +00:00
|
|
|
}
|
2020-11-17 18:21:00 +00:00
|
|
|
|
|
|
|
/* default connections on SGSN side: First BVC of each NSE/SGSN */
|
|
|
|
for (i := 0; i < lengthof(g_pars.sgsn); i := i+1) {
|
|
|
|
f_connect_to_sgsn_bvc(i, g_pars.sgsn[i].vc_BSSGP_BVC[0]);
|
2020-11-15 19:02:59 +00:00
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
g_Tguard.start(pars.t_guard);
|
2020-12-09 13:33:18 +00:00
|
|
|
activate(as_gTguard(g_Tguard));
|
2020-09-08 16:58:22 +00:00
|
|
|
|
|
|
|
/* call the user-supplied test case function */
|
|
|
|
fn.apply(id);
|
2021-01-16 11:50:56 +00:00
|
|
|
|
|
|
|
for (i := 0; i < NUM_SGSN; i := i+1) {
|
|
|
|
if (SGSN_PROC[i].checkstate("Connected")) {
|
|
|
|
f_client_unregister(g_pars.imsi, SGSN_PROC[i])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i := 0; i < NUM_PCU; i := i+1) {
|
|
|
|
if (PCU_PROC[i].checkstate("Connected")) {
|
|
|
|
f_client_unregister(g_pars.imsi, PCU_PROC[i])
|
|
|
|
}
|
|
|
|
}
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
|
2020-11-15 19:02:59 +00:00
|
|
|
private function f_client_register(hexstring imsi, OCT4 tlli, BSSGP_PROC_PT PT)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
|
|
|
PT.call(BSSGP_register_client:{imsi, tlli}) {
|
|
|
|
[] PT.getreply(BSSGP_register_client:{imsi, tlli}) {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private function f_client_unregister(hexstring imsi, BSSGP_PROC_PT PT)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
|
|
|
PT.call(BSSGP_unregister_client:{imsi}) {
|
|
|
|
[] PT.getreply(BSSGP_unregister_client:{imsi}) {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-16 12:35:14 +00:00
|
|
|
/* Send 'tx' on PTP-BVCI from PCU; expect 'rx' on SGSN */
|
|
|
|
friend function f_pcu2sgsn(template (value) PDU_BSSGP tx, template (present) PDU_BSSGP exp_rx,
|
2021-01-16 10:07:01 +00:00
|
|
|
integer pcu_idx := 0, boolean use_sig := false) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer sgsn_idx := g_pars.sgsn_idx;
|
2020-11-16 12:35:14 +00:00
|
|
|
var PDU_BSSGP rx;
|
2021-01-26 14:43:41 +00:00
|
|
|
timer T := 2.0;
|
2020-11-16 12:35:14 +00:00
|
|
|
|
2020-11-24 15:23:29 +00:00
|
|
|
if (use_sig) {
|
|
|
|
PCU_SIG[pcu_idx].send(tx);
|
|
|
|
} else {
|
2020-12-09 11:32:32 +00:00
|
|
|
PCU_PTP[pcu_idx].send(tx);
|
2020-11-24 15:23:29 +00:00
|
|
|
}
|
|
|
|
|
2020-11-16 12:35:14 +00:00
|
|
|
T.start;
|
|
|
|
alt {
|
2020-11-24 15:23:29 +00:00
|
|
|
[use_sig] SGSN_SIG[sgsn_idx].receive(exp_rx) {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[not use_sig] SGSN_PTP[sgsn_idx].receive(exp_rx) {
|
2020-11-16 12:35:14 +00:00
|
|
|
setverdict(pass);
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] SGSN_PTP[sgsn_idx].receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Unexpected BSSGP on SGSN[", sgsn_idx, "] side: ", rx));
|
2020-11-16 12:35:14 +00:00
|
|
|
}
|
2020-11-24 15:23:29 +00:00
|
|
|
[] SGSN_SIG[sgsn_idx].receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Unexpected SIG BSSGP on SGSN[", sgsn_idx, "] side: ", rx));
|
2020-11-24 15:23:29 +00:00
|
|
|
}
|
2020-11-16 12:35:14 +00:00
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Timeout waiting for BSSGP on SGSN[", sgsn_idx, "] side: ", exp_rx));
|
2020-11-16 12:35:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-17 10:15:28 +00:00
|
|
|
/* Send 'tx' from PCU; expect 'exp_rx' on _any_ SGSN */
|
|
|
|
friend function f_pcu2any_sgsn(template (value) PDU_BSSGP tx, template (present) PDU_BSSGP exp_rx,
|
|
|
|
integer pcu_idx := 0, boolean use_sig := false)
|
|
|
|
runs on BSSGP_ConnHdlr return integer {
|
|
|
|
var integer rx_idx := -1;
|
|
|
|
var PDU_BSSGP rx;
|
2021-01-26 14:43:41 +00:00
|
|
|
timer T := 2.0;
|
2021-01-17 10:15:28 +00:00
|
|
|
|
|
|
|
if (use_sig) {
|
|
|
|
PCU_SIG[pcu_idx].send(tx);
|
|
|
|
} else {
|
|
|
|
PCU_PTP[pcu_idx].send(tx);
|
|
|
|
}
|
|
|
|
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[use_sig] any from SGSN_SIG.receive(exp_rx) -> @index value rx_idx {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
[not use_sig] any from SGSN_PTP.receive(exp_rx) -> @index value rx_idx {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
[] any from SGSN_PTP.receive(PDU_BSSGP:?) -> value rx @index value rx_idx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Unexpected BSSGP on SGSN[", rx_idx, "] side: ", rx));
|
2021-01-17 10:15:28 +00:00
|
|
|
}
|
|
|
|
[] any from SGSN_SIG.receive(PDU_BSSGP:?) -> value rx @index value rx_idx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Unexpected SIG BSSGP on SGSN[", rx_idx, "] side: ", rx));
|
2021-01-17 10:15:28 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Timeout waiting for BSSGP on SGSN side: ", exp_rx));
|
2021-01-17 10:15:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return rx_idx;
|
|
|
|
}
|
|
|
|
|
2020-11-16 12:35:14 +00:00
|
|
|
/* Send 'tx' on PTP-BVCI from SGSN; expect 'rx' on PCU */
|
|
|
|
friend function f_sgsn2pcu(template (value) PDU_BSSGP tx, template (present) PDU_BSSGP exp_rx,
|
2021-01-16 10:07:01 +00:00
|
|
|
integer pcu_idx := 0, boolean use_sig := false) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer sgsn_idx := g_pars.sgsn_idx;
|
2020-11-16 12:35:14 +00:00
|
|
|
var PDU_BSSGP rx;
|
2021-01-26 14:43:41 +00:00
|
|
|
timer T := 2.0;
|
2020-11-16 12:35:14 +00:00
|
|
|
|
2020-11-24 15:23:29 +00:00
|
|
|
if (use_sig) {
|
|
|
|
SGSN_SIG[sgsn_idx].send(tx);
|
|
|
|
} else {
|
2020-12-09 11:32:32 +00:00
|
|
|
SGSN_PTP[sgsn_idx].send(tx);
|
2020-11-24 15:23:29 +00:00
|
|
|
}
|
|
|
|
|
2020-11-16 12:35:14 +00:00
|
|
|
T.start;
|
|
|
|
alt {
|
2020-11-24 15:23:29 +00:00
|
|
|
[use_sig] PCU_SIG[pcu_idx].receive(exp_rx) {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[not use_sig] PCU_PTP[pcu_idx].receive(exp_rx) {
|
2020-11-16 12:35:14 +00:00
|
|
|
setverdict(pass);
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] PCU_PTP[pcu_idx].receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Unexpected BSSGP on PCU side: ", rx));
|
2020-11-16 12:35:14 +00:00
|
|
|
}
|
2020-11-24 15:23:29 +00:00
|
|
|
[] PCU_SIG[pcu_idx].receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Unexpected SIG BSSGP on PCU side: ", rx));
|
2020-11-24 15:23:29 +00:00
|
|
|
}
|
2020-11-16 12:35:14 +00:00
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Timeout waiting for BSSGP on PCU side: ", exp_rx));
|
2020-11-16 12:35:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-11-15 19:02:59 +00:00
|
|
|
|
2020-11-24 18:05:22 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* GlobaLTest_CT: Using the per-NSE GLOBAL ports on PCU + SGSN side
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
type component GlobalTest_CT extends test_CT {
|
|
|
|
port BSSGP_PT G_PCU[NUM_PCU];
|
2021-01-17 12:48:13 +00:00
|
|
|
var integer g_pcu_idx[NUM_PCU]; /* BVC index currently connected to G_PCU */
|
2020-11-24 18:05:22 +00:00
|
|
|
port BSSGP_PT G_SGSN[NUM_SGSN];
|
2021-01-17 12:48:13 +00:00
|
|
|
var integer g_sgsn_idx[NUM_SGSN]; /* BVC index currently connected to G_SGSN */
|
2021-01-16 20:56:17 +00:00
|
|
|
port BSSGP_PT RIM_PCU[NUM_PCU];
|
|
|
|
port BSSGP_PT RIM_SGSN[NUM_SGSN];
|
2020-11-24 18:05:22 +00:00
|
|
|
};
|
|
|
|
|
2020-12-09 14:10:55 +00:00
|
|
|
/* connect the signaling BVC of each NSE to the G_PCU / G_SGSN ports */
|
2020-11-24 18:05:22 +00:00
|
|
|
private function f_global_init() runs on GlobalTest_CT {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < lengthof(g_sgsn); i := i+1) {
|
|
|
|
connect(self:G_SGSN[i], g_sgsn[i].vc_BSSGP:GLOBAL);
|
2021-01-16 20:56:17 +00:00
|
|
|
connect(self:RIM_SGSN[i], g_sgsn[i].vc_BSSGP:RIM);
|
2020-11-24 18:05:22 +00:00
|
|
|
}
|
|
|
|
for (i := 0; i < lengthof(g_pcu); i := i+1) {
|
|
|
|
connect(self:G_PCU[i], g_pcu[i].vc_BSSGP:GLOBAL);
|
2021-01-16 20:56:17 +00:00
|
|
|
connect(self:RIM_PCU[i], g_pcu[i].vc_BSSGP:RIM);
|
2020-11-24 18:05:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-09 14:10:55 +00:00
|
|
|
/* connect the first PTP BVC of each NSE to the G_PCU / G_SGSN ports */
|
|
|
|
private function f_global_init_ptp() runs on GlobalTest_CT {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < lengthof(g_sgsn); i := i+1) {
|
2021-01-17 12:48:13 +00:00
|
|
|
log("Connecting G_SGSN[", i, "] to BVCI=", g_sgsn[i].cfg.bvc[0].bvci);
|
2020-12-09 14:10:55 +00:00
|
|
|
connect(self:G_SGSN[i], g_sgsn[i].vc_BSSGP_BVC[0]:GLOBAL);
|
2021-01-17 12:48:13 +00:00
|
|
|
g_sgsn_idx[i] := 0;
|
2020-12-09 14:10:55 +00:00
|
|
|
}
|
|
|
|
for (i := 0; i < lengthof(g_pcu); i := i+1) {
|
2021-01-17 12:48:13 +00:00
|
|
|
log("Connecting G_PCU[", i, "] to BVCI=", g_pcu[i].cfg.bvc[0].bvci);
|
2020-12-09 14:10:55 +00:00
|
|
|
connect(self:G_PCU[i], g_pcu[i].vc_BSSGP_BVC[0]:GLOBAL);
|
2021-01-17 12:48:13 +00:00
|
|
|
g_pcu_idx[i] := 0;
|
2020-12-09 14:10:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-17 12:48:13 +00:00
|
|
|
/* (re)connect G_SGSN[sgsn_idx] to a specific PTP BVCI */
|
|
|
|
private function f_global_ptp_connect_sgsn_bvci(integer sgsn_idx, BssgpBvci bvci) runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_bvc_idx := get_bvc_idx_for_bvci(g_sgsn[sgsn_idx], bvci);
|
|
|
|
var integer old_sgsn_bvc_idx := g_sgsn_idx[sgsn_idx];
|
|
|
|
disconnect(self:G_SGSN[sgsn_idx], g_sgsn[sgsn_idx].vc_BSSGP_BVC[old_sgsn_bvc_idx]:GLOBAL);
|
|
|
|
connect(self:G_SGSN[sgsn_idx], g_sgsn[sgsn_idx].vc_BSSGP_BVC[sgsn_bvc_idx]:GLOBAL);
|
|
|
|
g_sgsn_idx[sgsn_idx] := sgsn_bvc_idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* (re)connect G_PCU[pcu_idx] to a specific PTP BVCI */
|
|
|
|
private function f_global_ptp_connect_pcu_bvci(integer pcu_idx, BssgpBvci bvci) runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer pcu_bvc_idx := get_bvc_idx_for_bvci(g_pcu[pcu_idx], bvci);
|
|
|
|
var integer old_pcu_bvc_idx := g_pcu_idx[pcu_idx];
|
|
|
|
disconnect(self:G_PCU[pcu_idx], g_pcu[pcu_idx].vc_BSSGP_BVC[old_pcu_bvc_idx]:GLOBAL);
|
|
|
|
connect(self:G_PCU[pcu_idx], g_pcu[pcu_idx].vc_BSSGP_BVC[pcu_bvc_idx]:GLOBAL);
|
|
|
|
g_pcu_idx[pcu_idx] := pcu_bvc_idx;
|
|
|
|
}
|
|
|
|
|
2020-11-24 18:05:22 +00:00
|
|
|
/* Send 'tx' on PTP-BVCI from PCU; expect 'rx' on SGSN */
|
|
|
|
friend function f_global_pcu2sgsn(template (value) PDU_BSSGP tx, template (present) PDU_BSSGP exp_rx,
|
|
|
|
integer pcu_idx := 0, integer sgsn_idx := 0) runs on GlobalTest_CT {
|
2021-01-17 12:48:13 +00:00
|
|
|
var integer rx_idx;
|
2020-11-24 18:05:22 +00:00
|
|
|
var PDU_BSSGP rx;
|
2021-01-26 14:43:41 +00:00
|
|
|
timer T := 2.0;
|
2020-11-24 18:05:22 +00:00
|
|
|
|
|
|
|
G_PCU[pcu_idx].send(tx);
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[] G_SGSN[sgsn_idx].receive(exp_rx) {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
2021-01-17 12:48:13 +00:00
|
|
|
[] any from G_SGSN.receive(exp_rx) -> @index value rx_idx {
|
|
|
|
setverdict(fail, "BSSGP arrived on wrong SGSN[", rx_idx, "] instead of SGSN[", sgsn_idx, "]");
|
|
|
|
}
|
2020-11-24 18:05:22 +00:00
|
|
|
[] G_SGSN[sgsn_idx].receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Unexpected BSSGP on SGSN side: ", rx));
|
2020-11-24 18:05:22 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Timeout waiting for BSSGP on SGSN side: ", exp_rx));
|
2020-11-24 18:05:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send 'tx' on PTP-BVCI from SGSN; expect 'rx' on PCU */
|
|
|
|
friend function f_global_sgsn2pcu(template (value) PDU_BSSGP tx, template (present) PDU_BSSGP exp_rx,
|
|
|
|
integer sgsn_idx := 0, integer pcu_idx := 0) runs on GlobalTest_CT {
|
2021-01-17 12:48:13 +00:00
|
|
|
var integer rx_idx;
|
2020-11-24 18:05:22 +00:00
|
|
|
var PDU_BSSGP rx;
|
2021-01-26 14:43:41 +00:00
|
|
|
timer T := 2.0;
|
2020-11-24 18:05:22 +00:00
|
|
|
|
|
|
|
G_SGSN[sgsn_idx].send(tx);
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[] G_PCU[pcu_idx].receive(exp_rx) {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
2021-01-17 12:48:13 +00:00
|
|
|
[] any from G_PCU.receive(exp_rx) -> @index value rx_idx {
|
|
|
|
setverdict(fail, "BSSGP arrived on wrong PCU[", rx_idx, "] instead of PCU[", pcu_idx, "]");
|
|
|
|
}
|
2020-11-24 18:05:22 +00:00
|
|
|
[] G_PCU[pcu_idx].receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Unexpected BSSGP on PCU side: ", rx));
|
2020-11-24 18:05:22 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Timeout waiting for BSSGP on PCU side: ", exp_rx));
|
2020-11-24 18:05:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-09-08 16:58:22 +00:00
|
|
|
/* TODO:
|
|
|
|
* Detach without Attach
|
|
|
|
* SM procedures without attach / RAU
|
|
|
|
* ATTACH / RAU
|
|
|
|
** with / without authentication
|
|
|
|
** with / without P-TMSI allocation
|
|
|
|
* re-transmissions of LLC frames
|
|
|
|
* PDP Context activation
|
|
|
|
** with different GGSN config in SGSN VTY
|
|
|
|
** with different PDP context type (v4/v6/v46)
|
|
|
|
** timeout from GGSN
|
|
|
|
** multiple / secondary PDP context
|
|
|
|
*/
|
|
|
|
|
|
|
|
private function f_TC_BVC_bringup(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
f_sleep(5.0);
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
|
|
|
|
testcase TC_BVC_bringup() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_BVC_bringup), testcasename(), 51);
|
2020-09-08 16:58:22 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
friend function f_bssgp_suspend(integer ran_idx := 0) runs on BSSGP_ConnHdlr return OCT1 {
|
2020-11-17 17:20:00 +00:00
|
|
|
var BssgpBvcConfig bvcc := g_pars.pcu[ran_idx].cfg.bvc[0];
|
2020-09-08 16:58:22 +00:00
|
|
|
timer T := 5.0;
|
|
|
|
var PDU_BSSGP rx_pdu;
|
2020-11-17 17:20:00 +00:00
|
|
|
PCU_SIG[ran_idx].send(ts_BSSGP_SUSPEND(g_pars.tlli, bvcc.cell_id.ra_id));
|
2020-09-08 16:58:22 +00:00
|
|
|
T.start;
|
|
|
|
alt {
|
2020-11-17 17:20:00 +00:00
|
|
|
[] PCU_SIG[ran_idx].receive(tr_BSSGP_SUSPEND_ACK(g_pars.tlli, bvcc.cell_id.ra_id, ?)) -> value rx_pdu {
|
2020-09-08 16:58:22 +00:00
|
|
|
return rx_pdu.pDU_BSSGP_SUSPEND_ACK.suspend_Reference_Number.suspend_Reference_Number_value;
|
|
|
|
}
|
2020-11-17 17:20:00 +00:00
|
|
|
[] PCU_SIG[ran_idx].receive(tr_BSSGP_SUSPEND_NACK(g_pars.tlli, bvcc.cell_id.ra_id, ?)) -> value rx_pdu {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("SUSPEND-NACK in response to SUSPEND for TLLI ", g_pars.tlli));
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("No SUSPEND-ACK in response to SUSPEND for TLLI ", g_pars.tlli));
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return '00'O;
|
|
|
|
}
|
|
|
|
|
|
|
|
friend function f_bssgp_resume(OCT1 susp_ref, integer ran_idx := 0) runs on BSSGP_ConnHdlr {
|
2020-11-17 17:20:00 +00:00
|
|
|
var BssgpBvcConfig bvcc := g_pars.pcu[ran_idx].cfg.bvc[0];
|
2020-09-08 16:58:22 +00:00
|
|
|
timer T := 5.0;
|
2020-11-17 17:20:00 +00:00
|
|
|
PCU_SIG[ran_idx].send(ts_BSSGP_RESUME(g_pars.tlli, bvcc.cell_id.ra_id, susp_ref));
|
2020-09-08 16:58:22 +00:00
|
|
|
T.start;
|
|
|
|
alt {
|
2020-11-17 17:20:00 +00:00
|
|
|
[] PCU_SIG[ran_idx].receive(tr_BSSGP_RESUME_ACK(g_pars.tlli, bvcc.cell_id.ra_id));
|
|
|
|
[] PCU_SIG[ran_idx].receive(tr_BSSGP_RESUME_NACK(g_pars.tlli, bvcc.cell_id.ra_id, ?)) {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("RESUME-NACK in response to RESUME for TLLI ", g_pars.tlli));
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("No RESUME-ACK in response to SUSPEND for TLLI ", g_pars.tlli));
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-11-15 20:45:49 +00:00
|
|
|
/* send uplink-unitdata of a variety of different sizes; expect it to show up on SGSN */
|
|
|
|
private function f_TC_ul_unitdata(charstring id) runs on BSSGP_ConnHdlr {
|
2020-11-17 17:20:00 +00:00
|
|
|
var integer ran_idx := 0;
|
|
|
|
var BssgpBvcConfig bvcc := g_pars.pcu[ran_idx].cfg.bvc[0];
|
2020-11-15 20:45:49 +00:00
|
|
|
var integer i;
|
|
|
|
|
2020-11-29 15:04:07 +00:00
|
|
|
for (i := 0; i < max_fr_info_size-4; i := i+4) {
|
2020-11-15 20:45:49 +00:00
|
|
|
var octetstring payload := f_rnd_octstring(i);
|
2020-11-17 17:20:00 +00:00
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_UL_UD(g_pars.tlli, bvcc.cell_id, payload);
|
2020-11-15 20:45:49 +00:00
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
2020-11-17 17:20:00 +00:00
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_UL_UD(g_pars.tlli, bvcc.cell_id, payload);
|
2020-11-15 20:45:49 +00:00
|
|
|
|
2020-11-29 15:04:07 +00:00
|
|
|
log("UL-UNITDATA(payload_size=", i);
|
2020-11-16 12:35:14 +00:00
|
|
|
f_pcu2sgsn(pdu_tx, pdu_rx);
|
2020-11-15 20:45:49 +00:00
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
|
|
|
|
testcase TC_ul_unitdata() runs on test_CT
|
|
|
|
{
|
2021-02-11 13:28:01 +00:00
|
|
|
f_init(60.0);
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_ul_unitdata), testcasename(), 1);
|
2020-11-15 20:45:49 +00:00
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-05-28 13:05:41 +00:00
|
|
|
|
|
|
|
/* send uplink-unitdata of a variety of different sizes; expect it to show up on the only connected SGSN */
|
|
|
|
private function f_TC_ul_unitdata_pool_failure(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer ran_idx := 0;
|
|
|
|
var BssgpBvcConfig bvcc := g_pars.pcu[ran_idx].cfg.bvc[0];
|
|
|
|
var integer i;
|
|
|
|
|
|
|
|
/* All data should arrive at the one SGSN that is still up */
|
|
|
|
g_pars.sgsn_idx := 0;
|
|
|
|
|
|
|
|
for (i := 0; i < max_fr_info_size-4; i := i+4) {
|
|
|
|
var octetstring payload := f_rnd_octstring(i);
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_UL_UD(g_pars.tlli, bvcc.cell_id, payload);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_UL_UD(g_pars.tlli, bvcc.cell_id, payload);
|
|
|
|
|
|
|
|
log("UL-UNITDATA(payload_size=", i);
|
|
|
|
f_pcu2sgsn(pdu_tx, pdu_rx);
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
|
|
|
|
testcase TC_ul_unitdata_pool_failure() runs on test_CT
|
|
|
|
{
|
|
|
|
var integer i;
|
|
|
|
var integer j;
|
|
|
|
|
|
|
|
f_init(60.0);
|
|
|
|
|
|
|
|
for (i := 1; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
|
|
|
connect(self:NS_CTRL, g_sgsn[i].vc_NS:NS_CTRL);
|
|
|
|
for (j := 0; j < lengthof(mp_nsconfig_sgsn[i].nsvc); j := j+1) {
|
|
|
|
var uint16_t nsvci := mp_nsconfig_sgsn[i].nsvc[j].nsvci;
|
|
|
|
var NsDisableVcRequest tx_disar;
|
|
|
|
tx_disar.nsvci := nsvci;
|
|
|
|
NS_CTRL.send(tx_disar);
|
|
|
|
}
|
|
|
|
disconnect(self:NS_CTRL, g_sgsn[i].vc_NS:NS_CTRL);
|
|
|
|
}
|
|
|
|
/* Wait until gbproxy notices that the NSVCs are down */
|
|
|
|
f_sleep(15.0);
|
|
|
|
|
|
|
|
f_start_handlers(refers(f_TC_ul_unitdata_pool_failure), testcasename(), 1);
|
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-15 22:27:27 +00:00
|
|
|
/* send downlink-unitdata of a variety of different sizes; expect it to show up on PCU */
|
|
|
|
private function f_TC_dl_unitdata(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer i;
|
|
|
|
|
2020-11-29 15:04:07 +00:00
|
|
|
for (i := 0; i < max_fr_info_size-4; i := i+4) {
|
2020-11-15 22:27:27 +00:00
|
|
|
var octetstring payload := f_rnd_octstring(i);
|
|
|
|
var template (value) PDU_BSSGP pdu_tx :=
|
|
|
|
ts_BSSGP_DL_UD(g_pars.tlli, payload, omit, ts_BSSGP_IMSI(g_pars.imsi));
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx :=
|
2021-02-11 13:22:42 +00:00
|
|
|
tr_BSSGP_DL_UD(g_pars.tlli, payload, tr_BSSGP_IMSI(g_pars.imsi));
|
2020-11-15 22:27:27 +00:00
|
|
|
|
2020-11-29 15:04:07 +00:00
|
|
|
log("DL-UNITDATA(payload_size=", i);
|
2020-11-16 12:35:14 +00:00
|
|
|
f_sgsn2pcu(pdu_tx, pdu_rx);
|
2020-11-15 22:27:27 +00:00
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
|
|
|
|
testcase TC_dl_unitdata() runs on test_CT
|
|
|
|
{
|
2021-02-11 13:28:01 +00:00
|
|
|
f_init(60.0);
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_dl_unitdata), testcasename(), 2);
|
2020-11-15 22:27:27 +00:00
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
2020-11-15 20:45:49 +00:00
|
|
|
|
2020-11-16 08:16:17 +00:00
|
|
|
private function f_TC_ra_capability(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer i;
|
|
|
|
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_RA_CAP(g_pars.tlli, { ts_RaCapRec_BSSGP });
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_RA_CAP(g_pars.tlli, { tr_RaCapRec_BSSGP })
|
|
|
|
|
2020-11-16 12:35:14 +00:00
|
|
|
f_sgsn2pcu(pdu_tx, pdu_rx);
|
2020-11-16 08:16:17 +00:00
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
testcase TC_ra_capability() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_ra_capability), testcasename(), 3);
|
2020-11-16 08:16:17 +00:00
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-16 18:53:26 +00:00
|
|
|
private function f_TC_ra_capability_upd(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer i;
|
|
|
|
var OCT1 tag;
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
|
|
|
tag := int2oct(23 + i, 1);
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_RA_CAP_UPD(g_pars.tlli, tag);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_RA_CAP_UPD(g_pars.tlli, tag)
|
|
|
|
|
|
|
|
f_pcu2sgsn(pdu_tx, pdu_rx);
|
|
|
|
|
|
|
|
pdu_tx := ts_BSSGP_RA_CAP_UPD_ACK(g_pars.tlli, tag, '42'O);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
pdu_rx := tr_BSSGP_RA_CAP_UPD_ACK(g_pars.tlli, tag, '42'O)
|
|
|
|
|
|
|
|
f_sgsn2pcu(pdu_tx, pdu_rx);
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
testcase TC_ra_capability_upd() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_ra_capability_upd), testcasename(), 4);
|
2020-11-16 18:53:26 +00:00
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-19 13:27:29 +00:00
|
|
|
private function f_TC_radio_status(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer i;
|
|
|
|
var BssgpRadioCause cause := BSSGP_RADIO_CAUSE_CONTACT_LOST;
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_RADIO_STATUS(g_pars.tlli, cause);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_RADIO_STATUS(g_pars.tlli, cause)
|
|
|
|
|
|
|
|
f_pcu2sgsn(pdu_tx, pdu_rx);
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
testcase TC_radio_status() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_radio_status), testcasename(), 5);
|
2020-11-19 13:27:29 +00:00
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-17 10:15:28 +00:00
|
|
|
private function f_TC_radio_status_tmsi(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer i;
|
|
|
|
var BssgpRadioCause cause := BSSGP_RADIO_CAUSE_CONTACT_LOST;
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
|
|
|
var integer tmsi_int := oct2int(g_pars.p_tmsi);
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_RADIO_STATUS(omit, cause, tmsi_int);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_RADIO_STATUS(omit, cause, tmsi_int);
|
|
|
|
f_pcu2sgsn(pdu_tx, pdu_rx);
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
testcase TC_radio_status_tmsi() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_radio_status_tmsi), testcasename(), 5);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
private function f_TC_radio_status_imsi(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer i;
|
|
|
|
var BssgpRadioCause cause := BSSGP_RADIO_CAUSE_CONTACT_LOST;
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_RADIO_STATUS(omit, cause, imsi := g_pars.imsi);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_RADIO_STATUS(omit, cause, imsi := g_pars.imsi);
|
|
|
|
f_pcu2any_sgsn(pdu_tx, pdu_rx);
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
testcase TC_radio_status_imsi() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_radio_status_imsi), testcasename(), 5);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2021-01-15 19:38:58 +00:00
|
|
|
private function f_suspend_one(integer sgsn_idx, integer nri_idx, integer pcu_idx, integer bvc_idx,
|
|
|
|
integer suffix)
|
2021-01-15 19:33:11 +00:00
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var RoutingAreaIdentification ra_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id.ra_id;
|
2021-01-15 19:38:58 +00:00
|
|
|
var OCT4 p_tmsi := f_gen_tmsi(suffix, nri_v := mp_sgsn_nri[sgsn_idx][nri_idx],
|
|
|
|
nri_bitlen := mp_nri_bitlength);
|
|
|
|
var OCT4 tlli := f_gprs_tlli_from_tmsi(p_tmsi, TLLI_LOCAL);
|
2021-01-15 19:33:11 +00:00
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_SUSPEND(tlli, ra_id);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_SUSPEND(tlli, ra_id);
|
|
|
|
f_global_pcu2sgsn(pdu_tx, pdu_rx, pcu_idx, sgsn_idx);
|
|
|
|
|
|
|
|
pdu_tx := ts_BSSGP_SUSPEND_ACK(tlli, ra_id, int2oct(suffix, 1));
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
pdu_rx := tr_BSSGP_SUSPEND_ACK(tlli, ra_id, int2oct(suffix, 1));
|
|
|
|
f_global_sgsn2pcu(pdu_tx, pdu_rx, sgsn_idx, pcu_idx);
|
|
|
|
|
|
|
|
pdu_tx := ts_BSSGP_SUSPEND(tlli, ra_id);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
pdu_rx := tr_BSSGP_SUSPEND(tlli, ra_id);
|
|
|
|
f_global_pcu2sgsn(pdu_tx, pdu_rx, pcu_idx, sgsn_idx);
|
|
|
|
|
|
|
|
/* These messages are simple passed through so just also test sending NACK */
|
|
|
|
pdu_tx := ts_BSSGP_SUSPEND_NACK(tlli, ra_id, BSSGP_CAUSE_UNKNOWN_MS);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
pdu_rx := tr_BSSGP_SUSPEND_NACK(tlli, ra_id, BSSGP_CAUSE_UNKNOWN_MS);
|
|
|
|
f_global_sgsn2pcu(pdu_tx, pdu_rx, sgsn_idx, pcu_idx);
|
|
|
|
}
|
|
|
|
|
2021-01-15 20:04:35 +00:00
|
|
|
private function f_TC_suspend(integer sgsn_idx, integer nri_idx, integer pcu_idx, integer bvc_idx)
|
|
|
|
runs on GlobalTest_CT {
|
2020-11-19 14:48:05 +00:00
|
|
|
var integer i;
|
|
|
|
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
2021-01-15 20:04:35 +00:00
|
|
|
f_suspend_one(sgsn_idx, nri_idx, pcu_idx, bvc_idx, suffix := i);
|
2020-11-19 14:48:05 +00:00
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
2020-11-24 18:05:22 +00:00
|
|
|
testcase TC_suspend() runs on GlobalTest_CT
|
2020-11-19 14:48:05 +00:00
|
|
|
{
|
2021-01-15 20:04:35 +00:00
|
|
|
var integer sgsn_idx, nri_idx;
|
2020-11-19 14:48:05 +00:00
|
|
|
f_init();
|
2020-11-24 18:05:22 +00:00
|
|
|
f_global_init();
|
2021-01-15 20:04:35 +00:00
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx+1) {
|
|
|
|
for (nri_idx := 0; nri_idx < lengthof(mp_sgsn_nri[sgsn_idx]); nri_idx := nri_idx+1) {
|
|
|
|
f_TC_suspend(sgsn_idx, nri_idx, pcu_idx:=0, bvc_idx:=0);
|
|
|
|
}
|
|
|
|
}
|
2020-11-19 14:48:05 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
2020-11-16 08:16:17 +00:00
|
|
|
|
2021-01-15 19:38:58 +00:00
|
|
|
private function f_resume_one(integer sgsn_idx, integer nri_idx, integer pcu_idx, integer bvc_idx,
|
|
|
|
integer suffix)
|
2021-01-15 19:33:11 +00:00
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var RoutingAreaIdentification ra_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id.ra_id;
|
2021-01-15 19:38:58 +00:00
|
|
|
var OCT4 p_tmsi := f_gen_tmsi(suffix, nri_v := mp_sgsn_nri[sgsn_idx][nri_idx],
|
|
|
|
nri_bitlen := mp_nri_bitlength);
|
|
|
|
var OCT4 tlli := f_gprs_tlli_from_tmsi(p_tmsi, TLLI_LOCAL);
|
2021-01-15 19:33:11 +00:00
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_RESUME(tlli, ra_id, int2oct(suffix, 1));
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_RESUME(tlli, ra_id, int2oct(suffix, 1));
|
|
|
|
f_global_pcu2sgsn(pdu_tx, pdu_rx, pcu_idx, sgsn_idx);
|
|
|
|
|
|
|
|
pdu_tx := ts_BSSGP_RESUME_ACK(tlli, ra_id);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
pdu_rx := tr_BSSGP_RESUME_ACK(tlli, ra_id);
|
|
|
|
f_global_sgsn2pcu(pdu_tx, pdu_rx, sgsn_idx, pcu_idx);
|
|
|
|
|
|
|
|
pdu_tx := ts_BSSGP_RESUME(tlli, ra_id, int2oct(suffix, 1));
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
pdu_rx := tr_BSSGP_RESUME(tlli, ra_id, int2oct(suffix, 1));
|
|
|
|
f_global_pcu2sgsn(pdu_tx, pdu_rx, pcu_idx, sgsn_idx);
|
|
|
|
|
|
|
|
/* These messages are simple passed through so just also test sending NACK */
|
|
|
|
pdu_tx := ts_BSSGP_RESUME_NACK(tlli, ra_id, BSSGP_CAUSE_UNKNOWN_MS);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
pdu_rx := tr_BSSGP_RESUME_NACK(tlli, ra_id, BSSGP_CAUSE_UNKNOWN_MS);
|
|
|
|
f_global_sgsn2pcu(pdu_tx, pdu_rx, sgsn_idx, pcu_idx);
|
|
|
|
}
|
|
|
|
|
2021-01-15 20:04:35 +00:00
|
|
|
private function f_TC_resume(integer sgsn_idx, integer nri_idx, integer pcu_idx, integer bvc_idx)
|
|
|
|
runs on GlobalTest_CT {
|
2020-11-19 14:58:43 +00:00
|
|
|
var integer i;
|
|
|
|
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
2021-01-15 20:04:35 +00:00
|
|
|
f_resume_one(sgsn_idx, nri_idx, pcu_idx, bvc_idx, suffix := i);
|
2020-11-19 14:58:43 +00:00
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
2020-11-24 18:05:22 +00:00
|
|
|
testcase TC_resume() runs on GlobalTest_CT
|
2020-11-19 14:58:43 +00:00
|
|
|
{
|
2021-01-15 20:04:35 +00:00
|
|
|
var integer sgsn_idx, nri_idx;
|
2020-11-19 14:58:43 +00:00
|
|
|
f_init();
|
2020-11-24 18:05:22 +00:00
|
|
|
f_global_init();
|
2021-01-15 20:04:35 +00:00
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx+1) {
|
|
|
|
for (nri_idx := 0; nri_idx < lengthof(mp_sgsn_nri[sgsn_idx]); nri_idx := nri_idx+1) {
|
|
|
|
f_TC_resume(sgsn_idx, nri_idx, pcu_idx:=0, bvc_idx:=0);
|
|
|
|
}
|
|
|
|
}
|
2020-11-19 14:58:43 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-18 11:16:59 +00:00
|
|
|
/* test the load-sharing between multiple NS-VC on the BSS side */
|
|
|
|
private function f_TC_dl_ud_unidir(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var integer i;
|
|
|
|
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
|
|
|
var octetstring payload := f_rnd_octstring(i);
|
|
|
|
var template (value) PDU_BSSGP pdu_tx :=
|
|
|
|
ts_BSSGP_DL_UD(g_pars.tlli, payload, omit, ts_BSSGP_IMSI(g_pars.imsi));
|
2021-01-16 10:18:38 +00:00
|
|
|
SGSN_PTP[g_pars.sgsn_idx].send(pdu_tx);
|
2020-11-18 11:16:59 +00:00
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
2021-01-16 10:18:38 +00:00
|
|
|
|
|
|
|
private function f_TC_load_sharing_dl(integer sgsn_idx) runs on test_CT_NS
|
2020-11-18 11:16:59 +00:00
|
|
|
{
|
|
|
|
const integer num_ue := 10;
|
|
|
|
var BSSGP_ConnHdlr vc_conn[num_ue];
|
|
|
|
/* all BVC are now fully brought up. We disconnect BSSGP from NS on the BSS
|
|
|
|
* side so we get the raw NsUnitdataIndication and hence observe different
|
|
|
|
* NSVCI */
|
|
|
|
disconnect(g_pcu[0].vc_NS:NS_SP, g_pcu[0].vc_BSSGP:BSCP);
|
|
|
|
connect(g_pcu[0].vc_NS:NS_SP, self:NS);
|
|
|
|
|
|
|
|
/* there may still be some NS-VCs coming up? After all, the BVC-RESET succeeds after the first
|
|
|
|
* of the NS-VC is ALIVE/UNBLOCKED */
|
|
|
|
f_sleep(3.0);
|
|
|
|
|
|
|
|
/* start parallel components generating DL-UNITDATA from the SGSN side */
|
|
|
|
for (var integer i:= 0; i < num_ue; i := i+1) {
|
2021-01-16 10:23:09 +00:00
|
|
|
vc_conn[i] := f_start_handler(refers(f_TC_dl_ud_unidir), testcasename(),
|
2021-01-16 10:18:38 +00:00
|
|
|
5+i, 30.0, sgsn_idx);
|
2020-11-18 11:16:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* now start counting all the messages that were queued before */
|
|
|
|
/* TODO: We have a hard-coded assumption of 4 NS-VC in one NSE/NS-VCG here! */
|
|
|
|
var ro_integer rx_count := { 0, 0, 0, 0 };
|
|
|
|
timer T := 2.0;
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[] as_NsUdiCount(0, rx_count);
|
|
|
|
[] as_NsUdiCount(1, rx_count);
|
|
|
|
[] as_NsUdiCount(2, rx_count);
|
|
|
|
[] as_NsUdiCount(3, rx_count);
|
|
|
|
[] NS.receive(NsUnitdataIndication:{0,?,?,*,*}) { repeat; } /* signaling BVC */
|
|
|
|
[] NS.receive(NsStatusIndication:?) { repeat; }
|
|
|
|
[] NS.receive {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, "Rx unexpected NS");
|
2020-11-18 11:16:59 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (var integer i := 0; i < lengthof(rx_count); i := i+1) {
|
|
|
|
log("Rx on NSVCI ", mp_nsconfig_pcu[0].nsvc[i].nsvci, ": ", rx_count[i]);
|
|
|
|
if (rx_count[i] == 0) {
|
|
|
|
setverdict(fail, "Data not shared over all NSVC");
|
|
|
|
}
|
|
|
|
}
|
2021-01-16 10:18:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
testcase TC_load_sharing_dl() runs on test_CT_NS
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, nri_idx;
|
|
|
|
f_init();
|
|
|
|
for (sgsn_idx:=0; sgsn_idx < NUM_SGSN; sgsn_idx:=sgsn_idx+1) {
|
|
|
|
f_TC_load_sharing_dl(sgsn_idx);
|
|
|
|
}
|
2020-11-18 11:16:59 +00:00
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
private altstep as_NsUdiCount(integer nsvc_idx, inout ro_integer roi) runs on test_CT_NS {
|
|
|
|
var NsUnitdataIndication udi;
|
|
|
|
var BssgpBvcConfig bvcc := g_pcu[0].cfg.bvc[0];
|
|
|
|
[] NS.receive(NsUnitdataIndication:{bvcc.bvci, g_pcu[0].cfg.nsei, mp_nsconfig_pcu[0].nsvc[nsvc_idx].nsvci, *, *}) -> value udi {
|
|
|
|
roi[nsvc_idx] := roi[nsvc_idx] + 1;
|
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
type component test_CT_NS extends test_CT {
|
|
|
|
port NS_PT NS;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* PAGING PS procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
private function f_send_paging_ps(template (value) Paging_Field4 p4, integer sgsn_idx := 0,
|
|
|
|
boolean use_sig := false)
|
|
|
|
runs on BSSGP_ConnHdlr return template (present) PDU_BSSGP {
|
|
|
|
var template (value) PDU_BSSGP pdu_tx;
|
|
|
|
var template (present) PDU_BSSGP pdu_rx;
|
|
|
|
/* we always specify '0' as BVCI in the templates below, as we override it with
|
|
|
|
* 'p4' later anyway */
|
|
|
|
pdu_rx := tr_BSSGP_PS_PAGING(0);
|
|
|
|
pdu_rx.pDU_BSSGP_PAGING_PS.iMSI := tr_BSSGP_IMSI(g_pars.imsi);
|
|
|
|
if (ispresent(g_pars.p_tmsi)) {
|
|
|
|
pdu_tx := ts_BSSGP_PS_PAGING_PTMSI(0, g_pars.imsi, oct2int(g_pars.p_tmsi));
|
|
|
|
pdu_rx.pDU_BSSGP_PAGING_PS.pTMSI := tr_BSSGP_TMSI(oct2int(g_pars.p_tmsi));
|
|
|
|
} else {
|
|
|
|
pdu_tx := ts_BSSGP_PS_PAGING_IMSI(0, g_pars.imsi);
|
|
|
|
pdu_rx.pDU_BSSGP_PAGING_PS.pTMSI := omit;
|
|
|
|
}
|
|
|
|
pdu_tx.pDU_BSSGP_PAGING_PS.paging_Field4 := p4;
|
|
|
|
pdu_rx.pDU_BSSGP_PAGING_PS.paging_Field4 := p4;
|
|
|
|
if (use_sig == false) {
|
2020-12-09 11:32:32 +00:00
|
|
|
SGSN_PTP[sgsn_idx].send(pdu_tx);
|
2020-11-22 20:46:48 +00:00
|
|
|
} else {
|
|
|
|
SGSN_SIG[sgsn_idx].send(pdu_tx);
|
|
|
|
}
|
|
|
|
return pdu_rx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* send paging defined by 'p4' on given SGSN-side index (ptp or signaling) and expect one paging to arrive on
|
|
|
|
* specified PCU index */
|
|
|
|
private function f_send_paging_ps_exp_one_bss(template (value) Paging_Field4 p4, integer sgsn_idx := 0,
|
|
|
|
boolean use_sig := false,integer pcu_idx := 0)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
2020-12-03 23:59:45 +00:00
|
|
|
var boolean test_done := false;
|
2020-11-22 20:46:48 +00:00
|
|
|
/* doesn't really make sense: Sending to a single BVCI means the message ends up
|
|
|
|
* at that BVC (cell) only, and paging all over the BSS area is not possible */
|
|
|
|
exp_rx := f_send_paging_ps(p4, sgsn_idx, use_sig);
|
|
|
|
/* Expect paging to propagate to the one BSS addressed by the BVCI only */
|
|
|
|
timer T := 2.0;
|
|
|
|
T.start;
|
|
|
|
alt {
|
2020-12-09 11:32:32 +00:00
|
|
|
[not use_sig and not test_done] PCU_PTP[pcu_idx].receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(pass);
|
2020-12-03 23:59:45 +00:00
|
|
|
test_done := true;
|
2020-11-22 20:46:48 +00:00
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
[not use_sig] PCU_SIG[pcu_idx].receive(exp_rx) {
|
|
|
|
setverdict(fail, "Received paging on SIGNALING BVC, expected PTP BVC");
|
|
|
|
}
|
2020-12-03 23:59:45 +00:00
|
|
|
[use_sig and not test_done] PCU_SIG[pcu_idx].receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(pass);
|
2020-12-03 23:59:45 +00:00
|
|
|
test_done := true;
|
2020-11-22 20:46:48 +00:00
|
|
|
repeat;
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[use_sig] PCU_PTP[pcu_idx].receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(fail, "Received paging on PTP BVC, expected SIGNALING BVC");
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] any from PCU_PTP.receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(fail, "Paging received on unexpected BVC");
|
|
|
|
}
|
|
|
|
[] any from PCU_SIG.receive(exp_rx) {
|
|
|
|
setverdict(fail, "Paging received on unexpected BVC");
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] any from PCU_PTP.receive(PDU_BSSGP:{pDU_BSSGP_PAGING_PS:=?}) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(fail, "Different Paging than expected received PTP BVC");
|
|
|
|
}
|
|
|
|
[] any from PCU_SIG.receive(PDU_BSSGP:{pDU_BSSGP_PAGING_PS:=?}) {
|
|
|
|
setverdict(fail, "Different Paging than expected on SIGNALING BVC");
|
|
|
|
}
|
2020-12-03 23:59:45 +00:00
|
|
|
[not test_done] T.timeout {
|
|
|
|
setverdict(fail, "Timeout waiting for paging");
|
|
|
|
}
|
|
|
|
[test_done] T.timeout;
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* send a PS-PAGING but don't expect it to show up on any PTP or SIG BVC */
|
|
|
|
private function f_send_paging_ps_exp_no_bss(template (value) Paging_Field4 p4, integer sgsn_idx := 0,
|
|
|
|
boolean use_sig := false)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
|
|
|
exp_rx := f_send_paging_ps(p4, sgsn_idx, use_sig);
|
|
|
|
/* Expect paging to propagate to no BSS */
|
|
|
|
timer T := 2.0;
|
|
|
|
T.start;
|
|
|
|
alt {
|
2020-12-09 11:32:32 +00:00
|
|
|
[] any from PCU_PTP.receive(exp_rx) {
|
2020-11-23 21:07:07 +00:00
|
|
|
setverdict(fail, "Paging received on unexpected BVC");
|
|
|
|
}
|
|
|
|
[] any from PCU_SIG.receive(exp_rx) {
|
|
|
|
setverdict(fail, "Paging received on unexpected BVC");
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] any from PCU_PTP.receive(PDU_BSSGP:{pDU_BSSGP_PAGING_PS:=?}) {
|
2020-11-23 21:07:07 +00:00
|
|
|
setverdict(fail, "Different Paging received on PTP BVC");
|
|
|
|
}
|
|
|
|
[] any from PCU_SIG.receive(PDU_BSSGP:{pDU_BSSGP_PAGING_PS:=?}) {
|
|
|
|
setverdict(fail, "Different Paging received on SIGNALING BVC");
|
|
|
|
}
|
|
|
|
[] T.timeout {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
private function f_TC_paging_ps_ptp_bss(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* doesn't really make sense: Sending to a single BVCI means the message ends up
|
|
|
|
* at that BVC (cell) only, and paging all over the BSS area is not possible */
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_one_bss(ts_BssgpP4BssArea, g_pars.sgsn_idx, false, 0);
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_ptp_bss() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_ptp_bss), testcasename(), 9);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PS-PAGING on PTP-BVC for Location Area */
|
|
|
|
private function f_TC_paging_ps_ptp_lac(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
|
|
|
/* doesn't really make sense: Sending to a single BVCI means the message ends up
|
|
|
|
* at that BVC (cell) only, and paging all over the BSS area is not possible */
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_one_bss(ts_BssgpP4LAC(pcu_bvc_cfg[0].cell_id.ra_id.lai), g_pars.sgsn_idx, false, 0);
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_ptp_lac() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_ptp_lac), testcasename(), 10);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* PS-PAGING on PTP-BVC for unknown Location Area */
|
|
|
|
private function f_TC_paging_ps_ptp_lac_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var GSM_Types.LocationAreaIdentification unknown_la := {
|
|
|
|
mcc_mnc := '567F99'H,
|
|
|
|
lac := 33333
|
|
|
|
};
|
|
|
|
/* as it's sent on the PTP BVC, we expect it to pass even for unknown LAC */
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_one_bss(ts_BssgpP4LAC(unknown_la), g_pars.sgsn_idx, false, 0);
|
2020-11-23 21:07:07 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_ptp_lac_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_ptp_lac_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* PS-PAGING on PTP-BVC for Routeing Area */
|
|
|
|
private function f_TC_paging_ps_ptp_rac(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* doesn't really make sense: Sending to a single BVCI means the message ends up
|
|
|
|
* at that BVC (cell) only, and paging all over the BSS area is not possible */
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_one_bss(ts_BssgpP4RAC(pcu_bvc_cfg[0].cell_id.ra_id), g_pars.sgsn_idx, false, 0);
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_ptp_rac() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_ptp_rac), testcasename(), 11);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* PS-PAGING on PTP-BVC for unknown Routeing Area */
|
|
|
|
private function f_TC_paging_ps_ptp_rac_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var RoutingAreaIdentification unknown_ra := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := '567F99'H,
|
|
|
|
lac := 33333
|
|
|
|
},
|
|
|
|
rac := 254
|
|
|
|
};
|
|
|
|
/* as it's sent on the PTP BVC, we expect it to pass even for unknown RAC */
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_one_bss(ts_BssgpP4RAC(unknown_ra), g_pars.sgsn_idx, false, 0);
|
2020-11-23 21:07:07 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_ptp_rac_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_ptp_rac_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* PS-PAGING on PTP-BVC for BVCI (one cell) */
|
|
|
|
private function f_TC_paging_ps_ptp_bvci(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* this should be the normal case for MS in READY MM state after a lower layer failure */
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_one_bss(ts_BssgpP4Bvci(pcu_bvc_cfg[0].bvci), g_pars.sgsn_idx, false, 0);
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_ptp_bvci() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_ptp_bvci), testcasename(), 12);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-16 12:04:40 +00:00
|
|
|
|
|
|
|
/* PS-PAGING on PTP-BVC for BVCI (one cell) using IMSI only (no P-TMSI allocated) */
|
|
|
|
testcase TC_paging_ps_ptp_bvci_imsi() runs on test_CT {
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_paging_ps_ptp_bvci), testcasename(), 12, have_ptmsi:=false);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-16 14:20:46 +00:00
|
|
|
/* Rejected PS-PAGING on PTP-BVC for BVCI (one cell) */
|
|
|
|
testcase TC_paging_ps_reject_ptp_bvci() runs on test_CT {
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_paging_ps_reject_ptp_bvci), testcasename(), 16);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Rejected PS-PAGING on PTP-BVC for BVCI (one cell) using IMSI only (no P-TMSI allocated) */
|
|
|
|
private function f_TC_paging_ps_reject_ptp_bvci(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* first send the PS-PAGING from SGSN -> PCU */
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_one_bss(ts_BssgpP4Bvci(pcu_bvc_cfg[0].bvci), g_pars.sgsn_idx, false, 0);
|
2021-01-16 14:20:46 +00:00
|
|
|
/* then simulate the PS-PAGING-REJECT from the PCU */
|
|
|
|
f_send_paging_ps_rej(use_sig:=false);
|
|
|
|
}
|
|
|
|
testcase TC_paging_ps_reject_ptp_bvci_imsi() runs on test_CT {
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_paging_ps_reject_ptp_bvci), testcasename(), 16, have_ptmsi:=false);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
2021-01-16 12:04:40 +00:00
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* PS-PAGING on PTP-BVC for unknown BVCI */
|
|
|
|
private function f_TC_paging_ps_ptp_bvci_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* as it's sent on the PTP BVC, we expect it to pass even for unknown BVCI */
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_one_bss(ts_BssgpP4Bvci(33333), g_pars.sgsn_idx, false, 0);
|
2020-11-23 21:07:07 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_ptp_bvci_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_ptp_bvci_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-16 18:09:20 +00:00
|
|
|
/* DUMMY PAGING PS on PTP BVC */
|
|
|
|
private function f_TC_dummy_paging_ps_ptp(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
f_sgsn2pcu(ts_BSSGP_DUMMY_PAGING_PS(g_pars.imsi, omit),
|
|
|
|
tr_BSSGP_DUMMY_PAGING_PS(g_pars.imsi, omit), use_sig := false);
|
|
|
|
f_pcu2sgsn(ts_BSSGP_DUMMY_PAGING_PS_RESP(g_pars.imsi, 1, 5),
|
|
|
|
tr_BSSGP_DUMMY_PAGING_PS_RESP(g_pars.imsi, 1, 5), use_sig := false)
|
|
|
|
}
|
|
|
|
testcase TC_dummy_paging_ps_ptp() runs on test_CT {
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_dummy_paging_ps_ptp), testcasename(), 11);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* altstep for expecting BSSGP PDU on signaling BVC of given pcu_idx + storing in 'roi' */
|
|
|
|
private altstep as_paging_sig_pcu(integer pcu_idx, template (present) PDU_BSSGP exp_rx, inout ro_integer roi)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
|
|
|
[] PCU_SIG[pcu_idx].receive(exp_rx) {
|
|
|
|
if (ro_integer_contains(roi, pcu_idx)) {
|
|
|
|
setverdict(fail, "Received multiple paging on same SIG BVC");
|
|
|
|
}
|
|
|
|
roi := roi & { pcu_idx };
|
|
|
|
repeat;
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] PCU_PTP[pcu_idx].receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(fail, "Received paging on PTP BVC, expected SIGNALING BVC");
|
|
|
|
}
|
|
|
|
[] PCU_SIG[pcu_idx].receive(PDU_BSSGP:{pDU_BSSGP_PAGING_PS:=?}) {
|
|
|
|
setverdict(fail, "Different Paging than expected received SIGNALING BVC");
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] PCU_PTP[pcu_idx].receive(PDU_BSSGP:{pDU_BSSGP_PAGING_PS:=?}) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(fail, "Different Paging than expected received PTP BVC");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type record of default ro_default;
|
|
|
|
|
|
|
|
/* send PS-PAGING on SIG BVC, expect it to arrive on given list of PCU indexes */
|
|
|
|
private function f_send_paging_ps_exp_multi(template (value) Paging_Field4 p4, integer sgsn_idx := 0,
|
|
|
|
ro_integer exp_on_pcu_idx) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
2021-01-17 11:55:53 +00:00
|
|
|
exp_rx := f_send_paging_ps(p4, sgsn_idx, true);
|
2020-11-22 20:46:48 +00:00
|
|
|
|
|
|
|
/* FIXME: make sure the relevant BVCs/BSS are connected to the ports! */
|
|
|
|
var ro_default defaults := {};
|
|
|
|
for (var integer i := 0; i < lengthof(mp_nsconfig_pcu); i := i+1) {
|
|
|
|
var default d := activate(as_paging_sig_pcu(i, exp_rx, g_roi));
|
|
|
|
defaults := defaults & { d };
|
|
|
|
}
|
|
|
|
f_sleep(2.0);
|
|
|
|
for (var integer i := 0; i < lengthof(defaults); i := i+1) {
|
|
|
|
deactivate(defaults[i]);
|
|
|
|
}
|
|
|
|
log("Paging received on PCU ", g_roi);
|
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(mp_nsconfig_pcu); i := i+1) {
|
|
|
|
var boolean rx_on_i := ro_integer_contains(g_roi, i);
|
|
|
|
var boolean exp_on_i := ro_integer_contains(exp_on_pcu_idx, i);
|
|
|
|
if (exp_on_i and not rx_on_i) {
|
|
|
|
setverdict(fail, "PS-PAGING not received on ", mp_nsconfig_pcu[i].nsei);
|
|
|
|
}
|
|
|
|
if (not exp_on_i and rx_on_i) {
|
|
|
|
setverdict(fail, "PS-PAGING not expected but received on ", mp_nsconfig_pcu[i].nsei);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
|
2021-01-16 14:20:46 +00:00
|
|
|
/* Send PAGING-PS-REJECT on SIG BVC, expect it to arrive on the "right" SGSN */
|
|
|
|
private function f_send_paging_ps_rej(boolean use_sig := true, integer pcu_idx := 0) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var template (value) PDU_BSSGP pdu_tx;
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
|
|
|
var PDU_BSSGP pdu_rx;
|
|
|
|
timer T := 5.0;
|
|
|
|
var template (omit) GsmTmsi tmsi_int := omit;
|
|
|
|
|
|
|
|
if (ispresent(g_pars.p_tmsi)) {
|
|
|
|
tmsi_int := oct2int(g_pars.p_tmsi);
|
|
|
|
}
|
|
|
|
|
|
|
|
pdu_tx := ts_BSSGP_PAGING_PS_REJ(g_pars.imsi, 23, 42, tmsi_int);
|
|
|
|
exp_rx := tr_BSSGP_PAGING_PS_REJ(g_pars.imsi, 23, 42, tmsi_int);
|
|
|
|
|
|
|
|
if (use_sig) {
|
|
|
|
PCU_SIG[pcu_idx].send(pdu_tx);
|
|
|
|
} else {
|
|
|
|
PCU_PTP[pcu_idx].send(pdu_tx);
|
|
|
|
}
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[use_sig] SGSN_SIG[g_pars.sgsn_idx].receive(exp_rx) -> value pdu_rx {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
[use_sig] SGSN_SIG[g_pars.sgsn_idx].receive {
|
|
|
|
setverdict(fail, "Unexpected PDU on SGSN");
|
|
|
|
}
|
|
|
|
[use_sig] any from SGSN_SIG.receive(exp_rx) -> value pdu_rx {
|
|
|
|
setverdict(fail, "PAGING-PS-REJECT arrived on wrong SGSN");
|
|
|
|
}
|
|
|
|
[not use_sig] SGSN_PTP[g_pars.sgsn_idx].receive(exp_rx) -> value pdu_rx {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
[not use_sig] SGSN_PTP[g_pars.sgsn_idx].receive {
|
|
|
|
setverdict(fail, "Unexpected PDU on SGSN");
|
|
|
|
}
|
|
|
|
[not use_sig] any from SGSN_PTP.receive(exp_rx) -> value pdu_rx {
|
|
|
|
setverdict(fail, "PAGING-PS-REJECT arrived on wrong SGSN");
|
|
|
|
}
|
|
|
|
[] T.timeout {
|
|
|
|
setverdict(fail, "Timeout waiting for PAGING-PS-REJECT");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* PS-PAGING on SIG-BVC for BSS Area */
|
|
|
|
private function f_TC_paging_ps_sig_bss(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* we expect the paging to arrive on all three NSE */
|
2021-01-17 13:07:05 +00:00
|
|
|
f_send_paging_ps_exp_multi(ts_BssgpP4BssArea, g_pars.sgsn_idx, {0, 1, 2});
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_sig_bss() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_sig_bss), testcasename(), 13);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PS-PAGING on SIG-BVC for Location Area */
|
|
|
|
private function f_TC_paging_ps_sig_lac(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
/* The first LAC (13135) is shared by all three NSEs */
|
2021-01-17 13:07:05 +00:00
|
|
|
f_send_paging_ps_exp_multi(ts_BssgpP4LAC(pcu_bvc_cfg[0].cell_id.ra_id.lai), g_pars.sgsn_idx, {0, 1, 2});
|
2020-12-01 09:54:08 +00:00
|
|
|
/* Reset state */
|
|
|
|
g_roi := {};
|
|
|
|
/* Make LAC (13300) available on pcu index 2 */
|
|
|
|
f_connect_to_pcu_bvc(port_idx := 2, nse_idx := 2, bvc_idx := 1);
|
2021-01-17 13:07:05 +00:00
|
|
|
f_send_paging_ps_exp_multi(ts_BssgpP4LAC(pcu_bvc_cfg[2].cell_id.ra_id.lai), g_pars.sgsn_idx, {2});
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_sig_lac() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_sig_lac), testcasename(), 14);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* PS-PAGING on SIG-BVC for unknown Location Area */
|
|
|
|
private function f_TC_paging_ps_sig_lac_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var GSM_Types.LocationAreaIdentification unknown_la := {
|
|
|
|
mcc_mnc := '567F99'H,
|
|
|
|
lac := 33333
|
|
|
|
};
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_no_bss(ts_BssgpP4LAC(unknown_la), g_pars.sgsn_idx, true);
|
2020-11-23 21:07:07 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_sig_lac_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_sig_lac_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* PS-PAGING on SIG-BVC for Routeing Area */
|
|
|
|
private function f_TC_paging_ps_sig_rac(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
2020-12-01 09:54:08 +00:00
|
|
|
/* Only PCU index 0 has a matching BVC with the RA ID */
|
2021-01-17 13:07:05 +00:00
|
|
|
f_send_paging_ps_exp_multi(ts_BssgpP4RAC(pcu_bvc_cfg[0].cell_id.ra_id), g_pars.sgsn_idx, {0});
|
2020-12-01 09:54:08 +00:00
|
|
|
g_roi := {};
|
|
|
|
/* PCU index 1 and 2 have a matching BVC with the RA ID */
|
2021-01-17 13:07:05 +00:00
|
|
|
f_send_paging_ps_exp_multi(ts_BssgpP4RAC(pcu_bvc_cfg[2].cell_id.ra_id), g_pars.sgsn_idx, {1, 2});
|
2020-12-01 09:54:08 +00:00
|
|
|
g_roi := {};
|
|
|
|
/* PCU index 2 has two matching BVCs with the RA ID */
|
|
|
|
f_connect_to_pcu_bvc(port_idx := 2, nse_idx := 2, bvc_idx := 1);
|
2021-01-17 13:07:05 +00:00
|
|
|
f_send_paging_ps_exp_multi(ts_BssgpP4RAC(pcu_bvc_cfg[2].cell_id.ra_id), g_pars.sgsn_idx, {2});
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_sig_rac() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_sig_rac), testcasename(), 15);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* PS-PAGING on SIG-BVC for unknown Routeing Area */
|
|
|
|
private function f_TC_paging_ps_sig_rac_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var RoutingAreaIdentification unknown_ra := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := '567F99'H,
|
|
|
|
lac := 33333
|
|
|
|
},
|
|
|
|
rac := 254
|
|
|
|
};
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_no_bss(ts_BssgpP4RAC(unknown_ra), g_pars.sgsn_idx, true);
|
2020-11-23 21:07:07 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_sig_rac_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_sig_rac_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* PS-PAGING on SIG-BVC for BVCI (one cell) */
|
|
|
|
private function f_TC_paging_ps_sig_bvci(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
2021-01-17 13:07:05 +00:00
|
|
|
f_send_paging_ps_exp_multi(ts_BssgpP4Bvci(pcu_bvc_cfg[0].bvci), g_pars.sgsn_idx, {0});
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_sig_bvci() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_sig_bvci), testcasename(), 16);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-16 12:04:40 +00:00
|
|
|
/* PS-PAGING on SIG-BVC for BVCI (one cell) using IMSI only (no P-TMSI allocated) */
|
|
|
|
testcase TC_paging_ps_sig_bvci_imsi() runs on test_CT {
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_paging_ps_sig_bvci), testcasename(), 16, have_ptmsi:=false);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-16 14:20:46 +00:00
|
|
|
/* Rejected PS-PAGING on SIG-BVC for BVCI (one cell) */
|
|
|
|
private function f_TC_paging_ps_reject_sig_bvci(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* first send the PS-PAGING from SGSN -> PCU */
|
2021-01-17 13:07:05 +00:00
|
|
|
f_send_paging_ps_exp_multi(ts_BssgpP4Bvci(pcu_bvc_cfg[0].bvci), g_pars.sgsn_idx, {0});
|
2021-01-16 14:20:46 +00:00
|
|
|
/* then simulate the PS-PAGING-REJECT from the PCU */
|
|
|
|
f_send_paging_ps_rej(use_sig:=true);
|
|
|
|
|
|
|
|
}
|
|
|
|
testcase TC_paging_ps_reject_sig_bvci() runs on test_CT {
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_paging_ps_reject_sig_bvci), testcasename(), 16);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Rejected PS-PAGING on SIG-BVC for BVCI (one cell) using IMSI only (no P-TMSI allocated) */
|
|
|
|
testcase TC_paging_ps_reject_sig_bvci_imsi() runs on test_CT {
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_paging_ps_reject_sig_bvci), testcasename(), 16, have_ptmsi:=false);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* PS-PAGING on SIG-BVC for unknown BVCI */
|
|
|
|
private function f_TC_paging_ps_sig_bvci_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
2021-01-18 17:50:02 +00:00
|
|
|
f_send_paging_ps_exp_no_bss(ts_BssgpP4Bvci(33333), g_pars.sgsn_idx, true);
|
2020-11-23 21:07:07 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_ps_sig_bvci_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_ps_sig_bvci_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-16 18:09:20 +00:00
|
|
|
/* DUMMY PAGING PS on SIG BVC */
|
|
|
|
private function f_TC_dummy_paging_ps_sig(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
f_sgsn2pcu(ts_BSSGP_DUMMY_PAGING_PS(g_pars.imsi, omit),
|
|
|
|
tr_BSSGP_DUMMY_PAGING_PS(g_pars.imsi, omit), use_sig := true);
|
|
|
|
f_pcu2sgsn(ts_BSSGP_DUMMY_PAGING_PS_RESP(g_pars.imsi, 1, 5),
|
|
|
|
tr_BSSGP_DUMMY_PAGING_PS_RESP(g_pars.imsi, 1, 5), use_sig := true)
|
|
|
|
}
|
|
|
|
testcase TC_dummy_paging_ps_sig() runs on test_CT {
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_dummy_paging_ps_sig), testcasename(), 11);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* PAGING CS procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
private function f_send_paging_cs(template (value) Paging_Field4 p4, integer sgsn_idx := 0,
|
|
|
|
boolean use_sig := false)
|
|
|
|
runs on BSSGP_ConnHdlr return template (present) PDU_BSSGP {
|
|
|
|
var template (value) PDU_BSSGP pdu_tx;
|
|
|
|
var template (present) PDU_BSSGP pdu_rx;
|
|
|
|
/* we always specify '0' as BVCI in the templates below, as we override it with
|
|
|
|
* 'p4' later anyway */
|
|
|
|
pdu_rx := tr_BSSGP_CS_PAGING(0);
|
|
|
|
pdu_rx.pDU_BSSGP_PAGING_CS.iMSI := tr_BSSGP_IMSI(g_pars.imsi);
|
|
|
|
if (ispresent(g_pars.p_tmsi)) {
|
|
|
|
pdu_tx := ts_BSSGP_CS_PAGING_PTMSI(0, g_pars.imsi, oct2int(g_pars.p_tmsi));
|
|
|
|
pdu_rx.pDU_BSSGP_PAGING_CS.tMSI := tr_BSSGP_TMSI(oct2int(g_pars.p_tmsi));
|
|
|
|
} else {
|
|
|
|
pdu_tx := ts_BSSGP_CS_PAGING_IMSI(0, g_pars.imsi);
|
|
|
|
pdu_rx.pDU_BSSGP_PAGING_CS.tMSI := omit;
|
|
|
|
}
|
|
|
|
pdu_tx.pDU_BSSGP_PAGING_CS.paging_Field4 := p4;
|
|
|
|
pdu_rx.pDU_BSSGP_PAGING_CS.paging_Field4 := p4;
|
|
|
|
if (use_sig == false) {
|
2020-12-09 11:32:32 +00:00
|
|
|
SGSN_PTP[sgsn_idx].send(pdu_tx);
|
2020-11-22 20:46:48 +00:00
|
|
|
} else {
|
|
|
|
SGSN_SIG[sgsn_idx].send(pdu_tx);
|
|
|
|
}
|
|
|
|
return pdu_rx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* send paging defined by 'p4' on given SGSN-side index (ptp or signaling) and expect one paging to arrive on
|
|
|
|
* specified PCU index */
|
|
|
|
private function f_send_paging_cs_exp_one_bss(template (value) Paging_Field4 p4, integer sgsn_idx := 0,
|
|
|
|
boolean use_sig := false,integer pcu_idx := 0)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
2020-12-03 23:59:45 +00:00
|
|
|
var boolean test_done := false;
|
2020-11-22 20:46:48 +00:00
|
|
|
/* doesn't really make sense: Sending to a single BVCI means the message ends up
|
|
|
|
* at that BVC (cell) only, and paging all over the BSS area is not possible */
|
|
|
|
exp_rx := f_send_paging_cs(p4, sgsn_idx, use_sig);
|
|
|
|
/* Expect paging to propagate to the one BSS addressed by the BVCI only */
|
|
|
|
timer T := 2.0;
|
|
|
|
T.start;
|
|
|
|
alt {
|
2020-12-09 11:32:32 +00:00
|
|
|
[not use_sig and not test_done] PCU_PTP[pcu_idx].receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(pass);
|
2020-12-03 23:59:45 +00:00
|
|
|
test_done := true;
|
2020-11-22 20:46:48 +00:00
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
[not use_sig] PCU_SIG[pcu_idx].receive(exp_rx) {
|
|
|
|
setverdict(fail, "Received paging on SIGNALING BVC, expected PTP BVC");
|
|
|
|
}
|
2020-12-03 23:59:45 +00:00
|
|
|
[use_sig and not test_done] PCU_SIG[pcu_idx].receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(pass);
|
2020-12-03 23:59:45 +00:00
|
|
|
test_done := true;
|
2020-11-22 20:46:48 +00:00
|
|
|
repeat;
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[use_sig] PCU_PTP[pcu_idx].receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(fail, "Received paging on PTP BVC, expected SIGNALING BVC");
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] any from PCU_PTP.receive(exp_rx) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(fail, "Paging received on unexpected BVC");
|
|
|
|
}
|
|
|
|
[] any from PCU_SIG.receive(exp_rx) {
|
|
|
|
setverdict(fail, "Paging received on unexpected BVC");
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] any from PCU_PTP.receive(PDU_BSSGP:{pDU_BSSGP_PAGING_CS:=?}) {
|
2020-11-22 20:46:48 +00:00
|
|
|
setverdict(fail, "Different Paging than expected received PTP BVC");
|
|
|
|
}
|
|
|
|
[] any from PCU_SIG.receive(PDU_BSSGP:{pDU_BSSGP_PAGING_CS:=?}) {
|
|
|
|
setverdict(fail, "Different Paging than expected on SIGNALING BVC");
|
|
|
|
}
|
2020-12-03 23:59:45 +00:00
|
|
|
[not test_done] T.timeout {
|
|
|
|
setverdict(fail, "Timeout while waiting for paging")
|
|
|
|
}
|
|
|
|
[test_done] T.timeout;
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* send a CS-PAGING but don't expect it to show up on any PTP or SIG BVC */
|
|
|
|
private function f_send_paging_cs_exp_no_bss(template (value) Paging_Field4 p4, integer sgsn_idx := 0,
|
|
|
|
boolean use_sig := false)
|
|
|
|
runs on BSSGP_ConnHdlr {
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
|
|
|
exp_rx := f_send_paging_cs(p4, sgsn_idx, use_sig);
|
|
|
|
/* Expect paging to propagate to no BSS */
|
|
|
|
timer T := 2.0;
|
|
|
|
T.start;
|
|
|
|
alt {
|
2020-12-09 11:32:32 +00:00
|
|
|
[] any from PCU_PTP.receive(exp_rx) {
|
2020-11-23 21:07:07 +00:00
|
|
|
setverdict(fail, "Paging received on unexpected BVC");
|
|
|
|
}
|
|
|
|
[] any from PCU_SIG.receive(exp_rx) {
|
|
|
|
setverdict(fail, "Paging received on unexpected BVC");
|
|
|
|
}
|
2020-12-09 11:32:32 +00:00
|
|
|
[] any from PCU_PTP.receive(PDU_BSSGP:{pDU_BSSGP_PAGING_CS:=?}) {
|
2020-11-23 21:07:07 +00:00
|
|
|
setverdict(fail, "Different Paging received on PTP BVC");
|
|
|
|
}
|
|
|
|
[] any from PCU_SIG.receive(PDU_BSSGP:{pDU_BSSGP_PAGING_CS:=?}) {
|
|
|
|
setverdict(fail, "Different Paging received on SIGNALING BVC");
|
|
|
|
}
|
|
|
|
[] T.timeout {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
private function f_TC_paging_cs_ptp_bss(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* doesn't really make sense: Sending to a single BVCI means the message ends up
|
|
|
|
* at that BVC (cell) only, and paging all over the BSS area is not possible */
|
|
|
|
f_send_paging_cs_exp_one_bss(ts_BssgpP4BssArea, 0, false, 0);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_ptp_bss() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_ptp_bss), testcasename(), 17);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* CS-PAGING on PTP-BVC for Location Area */
|
|
|
|
private function f_TC_paging_cs_ptp_lac(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
|
|
|
/* doesn't really make sense: Sending to a single BVCI means the message ends up
|
|
|
|
* at that BVC (cell) only, and paging all over the BSS area is not possible */
|
|
|
|
f_send_paging_cs_exp_one_bss(ts_BssgpP4LAC(pcu_bvc_cfg[0].cell_id.ra_id.lai), 0, false, 0);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_ptp_lac() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_ptp_lac), testcasename(), 18);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* CS-PAGING on PTP-BVC for unknown Location Area */
|
|
|
|
private function f_TC_paging_cs_ptp_lac_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var GSM_Types.LocationAreaIdentification unknown_la := {
|
|
|
|
mcc_mnc := '567F99'H,
|
|
|
|
lac := 33333
|
|
|
|
};
|
|
|
|
/* as it's sent on the PTP BVC, we expect it to pass even for unknown LAC */
|
|
|
|
f_send_paging_cs_exp_one_bss(ts_BssgpP4LAC(unknown_la), 0, false, 0);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_ptp_lac_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_ptp_lac_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* CS-PAGING on PTP-BVC for Routeing Area */
|
|
|
|
private function f_TC_paging_cs_ptp_rac(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* doesn't really make sense: Sending to a single BVCI means the message ends up
|
|
|
|
* at that BVC (cell) only, and paging all over the BSS area is not possible */
|
|
|
|
f_send_paging_cs_exp_one_bss(ts_BssgpP4RAC(pcu_bvc_cfg[0].cell_id.ra_id), 0, false, 0);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_ptp_rac() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_ptp_rac), testcasename(), 19);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* CS-PAGING on PTP-BVC for unknown Routeing Area */
|
|
|
|
private function f_TC_paging_cs_ptp_rac_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var RoutingAreaIdentification unknown_ra := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := '567F99'H,
|
|
|
|
lac := 33333
|
|
|
|
},
|
|
|
|
rac := 254
|
|
|
|
};
|
|
|
|
/* as it's sent on the PTP BVC, we expect it to pass even for unknown RAC */
|
|
|
|
f_send_paging_cs_exp_one_bss(ts_BssgpP4RAC(unknown_ra), 0, false, 0);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_ptp_rac_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_ptp_rac_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* CS-PAGING on PTP-BVC for BVCI (one cell) */
|
|
|
|
private function f_TC_paging_cs_ptp_bvci(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* this should be the normal case for MS in READY MM state after a lower layer failure */
|
|
|
|
f_send_paging_cs_exp_one_bss(ts_BssgpP4Bvci(pcu_bvc_cfg[0].bvci), 0, false, 0);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_ptp_bvci() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_ptp_bvci), testcasename(), 20);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* CS-PAGING on PTP-BVC for unknown BVCI */
|
|
|
|
private function f_TC_paging_cs_ptp_bvci_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* as it's sent on the PTP BVC, we expect it to pass even for unknown BVCI */
|
|
|
|
f_send_paging_cs_exp_one_bss(ts_BssgpP4Bvci(33333), 0, false, 0);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_ptp_bvci_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_ptp_bvci_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* send CS-PAGING on SIG BVC, expect it to arrive on given list of PCU indexes */
|
|
|
|
private function f_send_paging_cs_exp_multi(template (value) Paging_Field4 p4, integer sgsn_idx := 0,
|
|
|
|
ro_integer exp_on_pcu_idx) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var template (present) PDU_BSSGP exp_rx;
|
|
|
|
exp_rx := f_send_paging_cs(p4, 0, true);
|
|
|
|
|
|
|
|
/* FIXME: make sure the relevant BVCs/BSS are connected to the ports! */
|
|
|
|
var ro_default defaults := {};
|
|
|
|
for (var integer i := 0; i < lengthof(mp_nsconfig_pcu); i := i+1) {
|
|
|
|
var default d := activate(as_paging_sig_pcu(i, exp_rx, g_roi));
|
|
|
|
defaults := defaults & { d };
|
|
|
|
}
|
|
|
|
f_sleep(2.0);
|
|
|
|
for (var integer i := 0; i < lengthof(defaults); i := i+1) {
|
|
|
|
deactivate(defaults[i]);
|
|
|
|
}
|
|
|
|
log("Paging received on PCU ", g_roi);
|
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(mp_nsconfig_pcu); i := i+1) {
|
|
|
|
var boolean rx_on_i := ro_integer_contains(g_roi, i);
|
|
|
|
var boolean exp_on_i := ro_integer_contains(exp_on_pcu_idx, i);
|
|
|
|
if (exp_on_i and not rx_on_i) {
|
|
|
|
setverdict(fail, "PS-PAGING not received on ", mp_nsconfig_pcu[i].nsei);
|
|
|
|
}
|
|
|
|
if (not exp_on_i and rx_on_i) {
|
|
|
|
setverdict(fail, "PS-PAGING not expected but received on ", mp_nsconfig_pcu[i].nsei);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* CS-PAGING on SIG-BVC for BSS Area */
|
|
|
|
private function f_TC_paging_cs_sig_bss(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
/* we expect the paging to arrive on all three NSE */
|
|
|
|
f_send_paging_cs_exp_multi(ts_BssgpP4BssArea, 0, {0, 1, 2});
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_sig_bss() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_sig_bss), testcasename(), 13);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* CS-PAGING on SIG-BVC for Location Area */
|
|
|
|
private function f_TC_paging_cs_sig_lac(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
2020-12-07 12:57:17 +00:00
|
|
|
/* The first LAC (13135) is shared by all three NSEs */
|
|
|
|
f_send_paging_cs_exp_multi(ts_BssgpP4LAC(pcu_bvc_cfg[0].cell_id.ra_id.lai), 0, {0, 1, 2});
|
|
|
|
/* Reset state */
|
|
|
|
g_roi := {};
|
|
|
|
/* Make LAC (13300) available on pcu index 2 */
|
|
|
|
f_connect_to_pcu_bvc(port_idx := 2, nse_idx := 2, bvc_idx := 1);
|
|
|
|
f_send_paging_cs_exp_multi(ts_BssgpP4LAC(pcu_bvc_cfg[2].cell_id.ra_id.lai), 0, {2});
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_cs_sig_lac() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_sig_lac), testcasename(), 14);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* CS-PAGING on SIG-BVC for unknown Location Area */
|
|
|
|
private function f_TC_paging_cs_sig_lac_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var GSM_Types.LocationAreaIdentification unknown_la := {
|
|
|
|
mcc_mnc := '567F99'H,
|
|
|
|
lac := 33333
|
|
|
|
};
|
|
|
|
f_send_paging_cs_exp_no_bss(ts_BssgpP4LAC(unknown_la), 0, true);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_sig_lac_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_sig_lac_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* CS-PAGING on SIG-BVC for Routeing Area */
|
|
|
|
private function f_TC_paging_cs_sig_rac(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
2020-12-07 12:57:17 +00:00
|
|
|
/* Only PCU index 0 has a matching BVC with the RA ID */
|
2020-11-22 20:46:48 +00:00
|
|
|
f_send_paging_cs_exp_multi(ts_BssgpP4RAC(pcu_bvc_cfg[0].cell_id.ra_id), 0, {0});
|
2020-12-07 12:57:17 +00:00
|
|
|
g_roi := {};
|
|
|
|
/* PCU index 1 and 2 have a matching BVC with the RA ID */
|
|
|
|
f_send_paging_cs_exp_multi(ts_BssgpP4RAC(pcu_bvc_cfg[2].cell_id.ra_id), 0, {1, 2});
|
|
|
|
g_roi := {};
|
|
|
|
/* PCU index 2 has two matching BVCs with the RA ID */
|
|
|
|
f_connect_to_pcu_bvc(port_idx := 2, nse_idx := 2, bvc_idx := 1);
|
|
|
|
f_send_paging_cs_exp_multi(ts_BssgpP4RAC(pcu_bvc_cfg[2].cell_id.ra_id), 0, {2});
|
2020-11-22 20:46:48 +00:00
|
|
|
}
|
|
|
|
testcase TC_paging_cs_sig_rac() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_sig_rac), testcasename(), 15);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* CS-PAGING on SIG-BVC for unknown Routeing Area */
|
|
|
|
private function f_TC_paging_cs_sig_rac_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
var RoutingAreaIdentification unknown_ra := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := '567F99'H,
|
|
|
|
lac := 33333
|
|
|
|
},
|
|
|
|
rac := 254
|
|
|
|
};
|
|
|
|
f_send_paging_cs_exp_no_bss(ts_BssgpP4RAC(unknown_ra), 0, true);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_sig_rac_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_sig_rac_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
/* CS-PAGING on SIG-BVC for BVCI (one cell) */
|
|
|
|
private function f_TC_paging_cs_sig_bvci(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
f_send_paging_cs_exp_multi(ts_BssgpP4Bvci(pcu_bvc_cfg[0].bvci), 0, {0});
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_sig_bvci() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_sig_bvci), testcasename(), 16);
|
2020-11-22 20:46:48 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-23 21:07:07 +00:00
|
|
|
/* CS-PAGING on SIG-BVC for unknown BVCI */
|
|
|
|
private function f_TC_paging_cs_sig_bvci_unknown(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
f_send_paging_cs_exp_no_bss(ts_BssgpP4Bvci(33333), 0, true);
|
|
|
|
}
|
|
|
|
testcase TC_paging_cs_sig_bvci_unknown() runs on test_CT {
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_paging_cs_sig_bvci_unknown), testcasename(), 11);
|
2020-11-23 21:07:07 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-12-09 11:25:51 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* FLUSH-LL procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
2020-11-24 13:50:59 +00:00
|
|
|
private function f_TC_flush_ll(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var BssgpBvci bvci := g_pars.pcu[0].cfg.bvc[0].bvci;
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < 10; i := i+1) {
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_FLUSH_LL(g_pars.tlli, bvci, bvci_new := bvci);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_FLUSH_LL(g_pars.tlli, bvci, bvci_new := bvci);
|
|
|
|
|
|
|
|
f_sgsn2pcu(pdu_tx, pdu_rx, use_sig := true);
|
|
|
|
|
|
|
|
pdu_tx := ts_BSSGP_FLUSH_LL_ACK(g_pars.tlli, int2oct(0, 1), 23, bvci_new := bvci);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
pdu_rx := tr_BSSGP_FLUSH_LL_ACK(g_pars.tlli, int2oct(0, 1), 23, bvci_new := bvci);
|
|
|
|
|
|
|
|
f_pcu2sgsn(pdu_tx, pdu_rx, use_sig := true);
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
testcase TC_flush_ll() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_flush_ll), testcasename(), 6);
|
2020-11-24 13:50:59 +00:00
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
2020-11-16 08:16:17 +00:00
|
|
|
|
2020-12-09 11:25:51 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* SGSN-INVOKE-TRACE procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
2020-11-27 21:37:23 +00:00
|
|
|
private altstep as_bssgp_g_pcu_count(integer pcu_idx, template (present) PDU_BSSGP exp_rx, inout ro_integer roi)
|
|
|
|
runs on GlobalTest_CT {
|
|
|
|
[] G_PCU[pcu_idx].receive(exp_rx) from g_pcu[pcu_idx].vc_BSSGP {
|
|
|
|
if (ro_integer_contains(roi, pcu_idx)) {
|
|
|
|
setverdict(fail, "Received multiple on same SIG BVC");
|
|
|
|
}
|
|
|
|
roi := roi & { pcu_idx };
|
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* send a INVOKE-TRACE from SGSN and expect to receive a copy on each NSE */
|
|
|
|
testcase TC_trace() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var BSSGP_ConnHdlr vc_conn;
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_INVOKE_TRACE('23'O, '4321'O);
|
|
|
|
var template (present) PDU_BSSGP exp_rx := ts_BSSGP_INVOKE_TRACE('23'O, '4321'O);
|
|
|
|
|
|
|
|
var ro_default defaults := {};
|
|
|
|
for (var integer i := 0; i < lengthof(g_pcu); i := i+1) {
|
|
|
|
activate(as_bssgp_g_pcu_count(i, exp_rx, g_roi));
|
|
|
|
}
|
|
|
|
G_SGSN[0].send(pdu_tx);
|
|
|
|
f_sleep(2.0);
|
|
|
|
for (var integer i := 0; i < lengthof(defaults); i := i+1) {
|
|
|
|
deactivate(defaults[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(g_pcu); i := i+1) {
|
|
|
|
if (not ro_integer_contains(g_roi, i)) {
|
|
|
|
setverdict(fail, "Failed to receive TRACE on PCU index ", i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-12-09 11:25:51 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* LLC-DISCARDED procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
2020-11-27 21:49:02 +00:00
|
|
|
private function f_TC_llc_discarded(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var BssgpBvci bvci := g_pars.pcu[0].cfg.bvc[0].bvci;
|
|
|
|
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BSSGP_LLC_DISCARDED(g_pars.tlli, 23, bvci, 2342);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BSSGP_LLC_DISCARDED(g_pars.tlli, 23, bvci, 2342);
|
|
|
|
|
|
|
|
f_pcu2sgsn(pdu_tx, pdu_rx, use_sig := true);
|
|
|
|
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
/* Send a LLC-DISCARDED from BSS side and expect it to show up on SGSN (SIG BVC) */
|
|
|
|
testcase TC_llc_discarded() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_llc_discarded), testcasename(), 6);
|
2020-11-27 21:49:02 +00:00
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-12-09 11:25:51 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* OVERLOAD procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
2020-11-28 15:11:11 +00:00
|
|
|
/* Send an OVERLOAD from SGSN side and expect it to show up on each PCU (SIG BVC) */
|
|
|
|
testcase TC_overload() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
|
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_OVERLOAD('1'B);
|
|
|
|
var template (present) PDU_BSSGP exp_rx := tr_OVERLOAD('1'B);
|
|
|
|
|
|
|
|
var ro_default defaults := {};
|
|
|
|
for (var integer i := 0; i < lengthof(g_pcu); i := i+1) {
|
|
|
|
activate(as_bssgp_g_pcu_count(i, exp_rx, g_roi));
|
|
|
|
}
|
|
|
|
G_SGSN[0].send(pdu_tx);
|
|
|
|
f_sleep(2.0);
|
|
|
|
for (var integer i := 0; i < lengthof(defaults); i := i+1) {
|
|
|
|
deactivate(defaults[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(g_pcu); i := i+1) {
|
|
|
|
if (not ro_integer_contains(g_roi, i)) {
|
|
|
|
setverdict(fail, "Failed to receive OVERLOAD on PCU index ", i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-12-09 11:25:51 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* BVC-BLOCK / BVC-UNBLOCK procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
2020-11-24 22:14:20 +00:00
|
|
|
private function f_block_ptp_bvc_from_pcu(integer pcu_idx, integer bvc_idx) runs on test_CT
|
|
|
|
{
|
|
|
|
var BSSGP_BVC_CT bvc_ct := g_pcu[pcu_idx].vc_BSSGP_BVC[bvc_idx];
|
|
|
|
var BssgpBvcConfig bvc_cfg := g_pcu[pcu_idx].cfg.bvc[bvc_idx];
|
|
|
|
var Nsei nsei_pcu := g_pcu[pcu_idx].cfg.nsei;
|
|
|
|
|
|
|
|
SGSN_MGMT.clear;
|
|
|
|
PCU_MGMT.clear;
|
|
|
|
|
|
|
|
/* block the PTP BVC from the PCU side */
|
|
|
|
PCU_MGMT.send(BssgpBlockRequest:{cause:=BSSGP_CAUSE_OM_INTERVENTION}) to bvc_ct;
|
|
|
|
/* expect state on both PCU and SGSN side to change */
|
|
|
|
interleave {
|
|
|
|
[] PCU_MGMT.receive(tr_BssgpStsInd(nsei_pcu, bvc_cfg.bvci, BVC_S_BLOCKED)) from bvc_ct;
|
2021-03-30 11:19:56 +00:00
|
|
|
[] SGSN_MGMT.receive(tr_BssgpStsInd(mp_nsconfig_sgsn[0].nsei, bvc_cfg.bvci, BVC_S_BLOCKED));
|
|
|
|
[] SGSN_MGMT.receive(tr_BssgpStsInd(mp_nsconfig_sgsn[1].nsei, bvc_cfg.bvci, BVC_S_BLOCKED));
|
|
|
|
/* Doesn't auto-scale with NUM_SGSN */
|
2020-11-24 22:14:20 +00:00
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
testcase TC_bvc_block_ptp() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_sleep(1.0);
|
|
|
|
f_block_ptp_bvc_from_pcu(0, 0);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
private function f_unblock_ptp_bvc_from_pcu(integer pcu_idx, integer bvc_idx) runs on test_CT
|
|
|
|
{
|
|
|
|
var BSSGP_BVC_CT bvc_ct := g_pcu[pcu_idx].vc_BSSGP_BVC[bvc_idx];
|
|
|
|
var BssgpBvcConfig bvc_cfg := g_pcu[pcu_idx].cfg.bvc[bvc_idx];
|
|
|
|
var Nsei nsei_pcu := g_pcu[pcu_idx].cfg.nsei;
|
|
|
|
|
|
|
|
SGSN_MGMT.clear;
|
|
|
|
PCU_MGMT.clear;
|
|
|
|
|
|
|
|
/* block the PTP BVC from the PCU side */
|
|
|
|
PCU_MGMT.send(BssgpUnblockRequest:{}) to bvc_ct;
|
|
|
|
/* expect state on both PCU and SGSN side to change */
|
|
|
|
interleave {
|
|
|
|
[] PCU_MGMT.receive(tr_BssgpStsInd(nsei_pcu, bvc_cfg.bvci, BVC_S_UNBLOCKED)) from bvc_ct;
|
2021-03-30 11:19:56 +00:00
|
|
|
[] SGSN_MGMT.receive(tr_BssgpStsInd(mp_nsconfig_sgsn[0].nsei, bvc_cfg.bvci, BVC_S_UNBLOCKED));
|
|
|
|
[] SGSN_MGMT.receive(tr_BssgpStsInd(mp_nsconfig_sgsn[1].nsei, bvc_cfg.bvci, BVC_S_UNBLOCKED));
|
|
|
|
/* Doesn't auto-scale with NUM_SGSN */
|
2020-11-24 22:14:20 +00:00
|
|
|
}
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
testcase TC_bvc_unblock_ptp() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_sleep(1.0);
|
|
|
|
f_block_ptp_bvc_from_pcu(0, 0);
|
|
|
|
f_sleep(1.0);
|
|
|
|
f_unblock_ptp_bvc_from_pcu(0, 0);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-12-09 11:25:51 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* BVC-RESET procedure
|
|
|
|
***********************************************************************/
|
2021-01-21 17:11:12 +00:00
|
|
|
private altstep as_count_bvc_reset(integer sgsn_idx, BssgpBvci bvci, inout roro_integer roroi)
|
|
|
|
runs on test_CT {
|
|
|
|
var BSSGP_BVC_CT sgsn_bvc_ct := f_get_sgsn_bvc_ct(sgsn_idx, bvci);
|
|
|
|
[] SGSN_MGMT.receive(BssgpResetIndication:{bvci}) from sgsn_bvc_ct {
|
|
|
|
roroi[sgsn_idx] := roroi[sgsn_idx] & { bvci };
|
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
}
|
2020-11-25 16:12:53 +00:00
|
|
|
private altstep as_ignore_status(BSSGP_BVC_MGMT_PT pt) {
|
|
|
|
[] pt.receive(BssgpStatusIndication:?) { repeat; }
|
|
|
|
}
|
|
|
|
private function f_get_sgsn_bvc_ct(integer sgsn_idx, BssgpBvci bvci) runs on test_CT return BSSGP_BVC_CT {
|
|
|
|
for (var integer i := 0; i < lengthof(g_sgsn[sgsn_idx].cfg.bvc); i := i+1) {
|
|
|
|
if (g_sgsn[sgsn_idx].cfg.bvc[i].bvci == bvci) {
|
|
|
|
return g_sgsn[sgsn_idx].vc_BSSGP_BVC[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
private function f_reset_ptp_bvc_from_pcu(integer pcu_idx, integer bvc_idx) runs on test_CT
|
|
|
|
{
|
|
|
|
var BSSGP_BVC_CT pcu_bvc_ct := g_pcu[pcu_idx].vc_BSSGP_BVC[bvc_idx];
|
|
|
|
var BssgpBvcConfig bvc_cfg := g_pcu[pcu_idx].cfg.bvc[bvc_idx];
|
|
|
|
var Nsei nsei_pcu := g_pcu[pcu_idx].cfg.nsei;
|
2021-01-21 17:11:12 +00:00
|
|
|
var ro_default defaults;
|
|
|
|
var integer i;
|
2020-11-25 16:12:53 +00:00
|
|
|
|
|
|
|
SGSN_MGMT.clear;
|
|
|
|
PCU_MGMT.clear;
|
|
|
|
|
2021-01-21 17:11:12 +00:00
|
|
|
for (i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
|
|
|
g_roroi[i] := {};
|
|
|
|
}
|
|
|
|
|
2020-11-25 16:12:53 +00:00
|
|
|
/* block the PTP BVC from the PCU side */
|
|
|
|
PCU_MGMT.send(BssgpResetRequest:{cause:=BSSGP_CAUSE_OM_INTERVENTION}) to pcu_bvc_ct;
|
2021-01-21 17:11:12 +00:00
|
|
|
|
2020-11-25 16:12:53 +00:00
|
|
|
/* expect state on both PCU and SGSN side to change */
|
2021-01-21 17:11:12 +00:00
|
|
|
defaults := { activate(as_ignore_status(SGSN_MGMT)) };
|
|
|
|
|
|
|
|
/* Activate altsteps: One for each SGSN */
|
|
|
|
for (i := 0; i < lengthof(g_sgsn); i := i+1) {
|
|
|
|
var default d := activate(as_count_bvc_reset(i, bvc_cfg.bvci, g_roroi));
|
|
|
|
defaults := defaults & { d };
|
2020-11-25 16:12:53 +00:00
|
|
|
}
|
2021-01-21 17:11:12 +00:00
|
|
|
|
|
|
|
timer T := 3.0;
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[] PCU_MGMT.receive(tr_BssgpStsInd(nsei_pcu, bvc_cfg.bvci, BVC_S_BLOCKED)) from pcu_bvc_ct {
|
|
|
|
g_roi := g_roi & { bvc_cfg.bvci };
|
|
|
|
repeat;
|
|
|
|
}
|
|
|
|
[] T.timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i := 0; i < lengthof(defaults); i := i+1) {
|
|
|
|
deactivate(defaults[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if BVC-RESET was received at all SGSNs */
|
|
|
|
for (i := 0; i < lengthof(g_sgsn); i := i+1) {
|
|
|
|
if (not ro_integer_contains(g_roroi[i], bvc_cfg.bvci)) {
|
|
|
|
setverdict(fail, "Missing SGSN[", i, "] BVC-BLOCK of BVCI=", bvc_cfg.bvci);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-25 16:12:53 +00:00
|
|
|
setverdict(pass);
|
2021-01-21 17:11:12 +00:00
|
|
|
f_cleanup();
|
2020-11-25 16:12:53 +00:00
|
|
|
}
|
|
|
|
/* Send a BVC-RESET for a PTP BVC from the BSS side: expect it to propagate */
|
|
|
|
testcase TC_bvc_reset_ptp_from_bss() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_sleep(3.0);
|
|
|
|
f_reset_ptp_bvc_from_pcu(0, 0);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-03-30 10:16:36 +00:00
|
|
|
private altstep as_count_bvc_sts(integer sgsn_idx, BssgpBvci bvci,
|
|
|
|
template (present) BvcState exp_bvc_state, inout roro_integer roroi)
|
2020-11-27 18:11:56 +00:00
|
|
|
runs on test_CT {
|
|
|
|
var BSSGP_BVC_CT sgsn_bvc_ct := f_get_sgsn_bvc_ct(sgsn_idx, bvci);
|
2021-03-30 10:16:36 +00:00
|
|
|
[] SGSN_MGMT.receive(tr_BssgpStsInd(?, bvci, exp_bvc_state)) from sgsn_bvc_ct {
|
2021-01-21 17:11:12 +00:00
|
|
|
roroi[sgsn_idx] := roroi[sgsn_idx] & { bvci };
|
2020-12-07 13:36:35 +00:00
|
|
|
repeat;
|
2020-11-27 18:11:56 +00:00
|
|
|
}
|
|
|
|
}
|
2021-03-30 10:16:36 +00:00
|
|
|
|
|
|
|
private altstep as_count_bvc_block(integer sgsn_idx, BssgpBvci bvci, inout roro_integer roroi)
|
|
|
|
runs on test_CT {
|
|
|
|
[] as_count_bvc_sts(sgsn_idx, bvci, BVC_S_BLOCKED, roroi);
|
|
|
|
}
|
|
|
|
|
|
|
|
private altstep as_count_bvc_unblock(integer sgsn_idx, BssgpBvci bvci, inout roro_integer roroi)
|
|
|
|
runs on test_CT {
|
|
|
|
[] as_count_bvc_sts(sgsn_idx, bvci, BVC_S_UNBLOCKED, roroi);
|
|
|
|
}
|
|
|
|
|
2020-11-27 18:11:56 +00:00
|
|
|
/* reset the signaling BVC from one BSS; expect no signaling BVC reset on SGSN; but BVC-BLOCK for PTP */
|
|
|
|
testcase TC_bvc_reset_sig_from_bss() runs on test_CT {
|
|
|
|
|
|
|
|
f_init();
|
|
|
|
f_sleep(3.0);
|
|
|
|
|
2021-01-21 17:11:12 +00:00
|
|
|
for (var integer i := 0; i < lengthof(mp_nsconfig_sgsn); i := i+1) {
|
|
|
|
g_roroi[i] := {};
|
|
|
|
}
|
|
|
|
|
2020-11-27 18:11:56 +00:00
|
|
|
/* Start BVC-RESET procedure for BVCI=0 */
|
|
|
|
PCU_MGMT.send(BssgpResetRequest:{cause:=BSSGP_CAUSE_OM_INTERVENTION}) to g_pcu[0].vc_BSSGP;
|
|
|
|
|
2021-01-21 17:11:12 +00:00
|
|
|
/* Activate altsteps: One for each PTP BVC and SGSN within that PCUs NSE */
|
2020-11-27 18:11:56 +00:00
|
|
|
var ro_default defaults := {};
|
|
|
|
for (var integer i := 0; i < lengthof(g_pcu[0].cfg.bvc); i := i+1) {
|
|
|
|
var BssgpBvcConfig bvcc := g_pcu[0].cfg.bvc[i];
|
2021-01-21 17:11:12 +00:00
|
|
|
for (var integer j := 0; j < lengthof(g_sgsn); j := j+1) {
|
|
|
|
var default d := activate(as_count_bvc_block(j, bvcc.bvci, g_roroi));
|
|
|
|
defaults := defaults & { d };
|
|
|
|
}
|
2020-11-27 18:11:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
timer T := 3.0;
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[] SGSN_MGMT.receive(BssgpResetIndication:{0}) {
|
|
|
|
setverdict(fail, "BSS-side Reset of BVCI=0 should not propagate");
|
|
|
|
}
|
|
|
|
[] T.timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(defaults); i := i+1) {
|
|
|
|
deactivate(defaults[i]);
|
|
|
|
}
|
|
|
|
|
2021-01-21 17:11:12 +00:00
|
|
|
/* check if BVC-block was received on all expected BVC/SGSN */
|
2020-11-27 18:11:56 +00:00
|
|
|
for (var integer i := 0; i < lengthof(g_pcu[0].cfg.bvc); i := i+1) {
|
|
|
|
var BssgpBvcConfig bvcc := g_pcu[0].cfg.bvc[i];
|
2021-01-21 17:11:12 +00:00
|
|
|
for (var integer j := 0; j < lengthof(g_sgsn); j := j+1) {
|
|
|
|
if (not ro_integer_contains(g_roroi[j], bvcc.bvci)) {
|
|
|
|
setverdict(fail, "Missing SGSN[", j, "] BVC-BLOCK of BVCI=", bvcc.bvci);
|
|
|
|
}
|
2020-11-27 18:11:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if BVC-block was not received on any unexpected BVC is not required as
|
|
|
|
* such a message would basically run into 'no matching clause' */
|
2020-12-04 13:20:50 +00:00
|
|
|
setverdict(pass);
|
2020-11-27 18:11:56 +00:00
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-11-25 16:12:53 +00:00
|
|
|
private function f_reset_ptp_bvc_from_sgsn(integer pcu_idx, integer bvc_idx) runs on test_CT
|
|
|
|
{
|
|
|
|
var BSSGP_BVC_CT pcu_bvc_ct := g_pcu[pcu_idx].vc_BSSGP_BVC[bvc_idx];
|
|
|
|
var BssgpBvcConfig bvc_cfg := g_pcu[pcu_idx].cfg.bvc[bvc_idx];
|
|
|
|
var Nsei nsei_pcu := g_pcu[pcu_idx].cfg.nsei;
|
|
|
|
var BSSGP_BVC_CT sgsn_bvc_ct := f_get_sgsn_bvc_ct(0, bvc_cfg.bvci);
|
|
|
|
var default d;
|
|
|
|
|
|
|
|
SGSN_MGMT.clear;
|
|
|
|
PCU_MGMT.clear;
|
|
|
|
|
|
|
|
/* block the PTP BVC from the PCU side */
|
|
|
|
SGSN_MGMT.send(BssgpResetRequest:{cause:=BSSGP_CAUSE_OM_INTERVENTION}) to sgsn_bvc_ct;
|
|
|
|
/* expect state on both PCU and SGSN side to change */
|
|
|
|
d := activate(as_ignore_status(PCU_MGMT));
|
|
|
|
interleave {
|
|
|
|
[] SGSN_MGMT.receive(tr_BssgpStsInd(?, bvc_cfg.bvci, BVC_S_BLOCKED)) from sgsn_bvc_ct;
|
|
|
|
[] PCU_MGMT.receive(BssgpResetIndication:{bvc_cfg.bvci}) from pcu_bvc_ct;
|
|
|
|
}
|
|
|
|
deactivate(d);
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
/* Send a BVC-RESET for a PTP BVC from the SGSN side: expect it to propagate */
|
|
|
|
testcase TC_bvc_reset_ptp_from_sgsn() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_sleep(3.0);
|
|
|
|
f_reset_ptp_bvc_from_sgsn(0, 0);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-07 23:43:56 +00:00
|
|
|
private altstep as_ignore_mgmt(BSSGP_BVC_MGMT_PT pt) {
|
|
|
|
[] pt.receive {repeat; }
|
|
|
|
}
|
|
|
|
|
2020-11-27 18:11:56 +00:00
|
|
|
private altstep as_count_bvc0_block(integer pcu_idx, Nsei nsei, inout ro_integer roi)
|
|
|
|
runs on test_CT {
|
|
|
|
var BSSGP_CT pcu_ct := g_pcu[pcu_idx].vc_BSSGP;
|
|
|
|
[] PCU_MGMT.receive(BssgpResetIndication:{0}) from pcu_ct {
|
|
|
|
roi := roi & { nsei };
|
2021-01-07 23:43:56 +00:00
|
|
|
repeat;
|
2020-11-27 18:11:56 +00:00
|
|
|
}
|
|
|
|
}
|
2021-01-07 23:43:56 +00:00
|
|
|
|
2020-11-27 18:11:56 +00:00
|
|
|
/* reset the signaling BVC from the SGSN; expect all signaling BVC on all BSS to be reset */
|
|
|
|
testcase TC_bvc_reset_sig_from_sgsn() runs on test_CT {
|
|
|
|
|
|
|
|
f_init();
|
|
|
|
f_sleep(3.0);
|
|
|
|
|
2021-01-07 23:43:56 +00:00
|
|
|
SGSN_MGMT.clear;
|
|
|
|
PCU_MGMT.clear;
|
|
|
|
|
2020-11-27 18:11:56 +00:00
|
|
|
/* Start BVC-RESET procedure for BVCI=0 */
|
|
|
|
SGSN_MGMT.send(BssgpResetRequest:{cause:=BSSGP_CAUSE_OM_INTERVENTION}) to g_sgsn[0].vc_BSSGP;
|
|
|
|
|
2021-01-07 23:43:56 +00:00
|
|
|
/* Defaults match in reverse activation order, this one is a catch-all for Status indications
|
|
|
|
* and reset indications sent from other components (like the ptp_bvcs). If we don't drain
|
|
|
|
* the port and a different message sits at the front we wait forever and fail the test.
|
|
|
|
*/
|
|
|
|
var ro_default defaults := { activate(as_ignore_mgmt(PCU_MGMT)) };
|
|
|
|
|
2020-11-27 18:11:56 +00:00
|
|
|
/* Activate altsteps: One for each PCU NSE */
|
|
|
|
for (var integer i := 0; i < lengthof(g_pcu); i := i+1) {
|
|
|
|
var NSConfiguration nscfg := mp_nsconfig_pcu[i];
|
|
|
|
var default d := activate(as_count_bvc0_block(i, nscfg.nsei, g_roi));
|
|
|
|
defaults := defaults & { d };
|
|
|
|
}
|
|
|
|
|
|
|
|
f_sleep(3.0);
|
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(defaults); i := i+1) {
|
|
|
|
deactivate(defaults[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if BVC-block was received on all expected BVC */
|
|
|
|
for (var integer i := 0; i < lengthof(g_pcu); i := i+1) {
|
|
|
|
var NSConfiguration nscfg := mp_nsconfig_pcu[i];
|
|
|
|
if (not ro_integer_contains(g_roi, nscfg.nsei)) {
|
|
|
|
setverdict(fail, "Missing PCU-side BVC-RESET of BVCI=0 on PCU index ", i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if BVC-block was not received on any unexpected BVC is not required as
|
|
|
|
* such a message would basically run into 'no matching clause' */
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-12-09 14:10:55 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* FLOW-CONTROL-BVC procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
private altstep as_g_count_sgsn(integer sgsn_idx, inout ro_integer roi,
|
|
|
|
template PDU_BSSGP exp_rx, template (omit) PDU_BSSGP tx_reply)
|
|
|
|
runs on GlobalTest_CT {
|
|
|
|
[] G_SGSN[sgsn_idx].receive(exp_rx) {
|
|
|
|
roi := roi & { sgsn_idx };
|
|
|
|
if (ispresent(tx_reply)) {
|
|
|
|
G_SGSN[sgsn_idx].send(tx_reply);
|
|
|
|
}
|
2021-01-15 20:07:52 +00:00
|
|
|
repeat;
|
2020-12-09 14:10:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Send FC-BVC from simulated PCU; expect each SGSN to receive it; expect PCU to receive ACK */
|
|
|
|
testcase TC_fc_bvc() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_global_init_ptp();
|
|
|
|
|
2021-02-05 12:05:06 +00:00
|
|
|
var template (value) PDU_BSSGP pdu_tx := ts_BVC_FC_BVC(10240, 2000, 1024, 1000, '01'O);
|
2020-12-09 14:10:55 +00:00
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP pdu_rx := tr_BVC_FC_BVC(10240, 2000, 1024, 1000, '01'O);
|
2021-02-05 12:05:06 +00:00
|
|
|
var template (value) PDU_BSSGP ack_tx :=
|
|
|
|
ts_BVC_FC_BVC_ACK(pdu_tx.pDU_BSSGP_FLOW_CONTROL_BVC.tag.unstructured_Value);
|
2020-12-09 14:10:55 +00:00
|
|
|
|
|
|
|
/* Send a FC-BVC from BSS to gbproxy, expect an ACK in response */
|
|
|
|
G_PCU[0].send(pdu_tx);
|
|
|
|
|
|
|
|
/* Activate altsteps: One for each SGSN-side PTP BVC port */
|
|
|
|
var ro_default defaults := {};
|
|
|
|
for (var integer i := 0; i < lengthof(g_sgsn); i := i+1) {
|
|
|
|
var default d := activate(as_g_count_sgsn(i, g_roi, pdu_rx, ack_tx));
|
|
|
|
defaults := defaults & { d };
|
|
|
|
}
|
|
|
|
|
|
|
|
f_sleep(3.0);
|
|
|
|
|
|
|
|
for (var integer i := 0; i < lengthof(defaults); i := i+1) {
|
|
|
|
deactivate(defaults[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if BVC-block was received on all expected BVC */
|
|
|
|
for (var integer i := 0; i < lengthof(g_sgsn); i := i+1) {
|
|
|
|
if (not ro_integer_contains(g_roi, i)) {
|
|
|
|
setverdict(fail, "Missing BVC-FLOW-CONTROL on SGSN index ", i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Expect ACK on PCU side */
|
|
|
|
G_PCU[0].receive(ack_tx);
|
|
|
|
|
|
|
|
setverdict(pass);
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2020-12-09 15:50:12 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* FLOW-CONTROL-MS procedure
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
private function f_TC_fc_ms(charstring id) runs on BSSGP_ConnHdlr {
|
|
|
|
var BssgpBvci bvci := g_pars.pcu[0].cfg.bvc[0].bvci;
|
|
|
|
|
|
|
|
var template (value) PDU_BSSGP fc_tx := ts_BVC_FC_MS(g_pars.tlli, 100, 200, '12'O);
|
|
|
|
/* we cannot use pdu_tx as there are some subtle differences in the length field :/ */
|
|
|
|
var template (present) PDU_BSSGP fc_rx := tr_BVC_FC_MS(g_pars.tlli, 100, 200, '12'O);
|
|
|
|
var template (value) PDU_BSSGP ack_tx := ts_BVC_FC_MS_ACK(g_pars.tlli, '12'O);
|
|
|
|
|
|
|
|
f_pcu2sgsn(fc_tx, fc_rx, use_sig := false);
|
|
|
|
f_sgsn2pcu(ack_tx, ack_tx, use_sig := false);
|
|
|
|
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
/* Send a FLOW-CONTROL-MS from BSS side and expect it to show up on SGSN (PTP BVC) */
|
|
|
|
testcase TC_fc_ms() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
2021-01-16 10:23:09 +00:00
|
|
|
f_start_handlers(refers(f_TC_fc_ms), testcasename(), 21);
|
2020-12-09 15:50:12 +00:00
|
|
|
/* TODO: start multiple handlers (UEs) on various cells on same and other NSEs */
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-16 17:57:49 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* MS-REGISTRATION ENQUIRY procedure
|
|
|
|
***********************************************************************/
|
2020-12-09 15:50:12 +00:00
|
|
|
|
2021-01-16 17:57:49 +00:00
|
|
|
private function f_TC_ms_reg_enq(charstring id) runs on BSSGP_ConnHdlr
|
|
|
|
{
|
|
|
|
f_pcu2sgsn(ts_BSSGP_MS_REG_ENQ(g_pars.imsi), tr_BSSGP_MS_REG_ENQ(g_pars.imsi), use_sig := true);
|
|
|
|
f_sgsn2pcu(ts_BSSGP_MS_REW_ENQ_RESP(g_pars.imsi, omit), tr_BSSGP_MS_REW_ENQ_RESP(g_pars.imsi, omit), use_sig := true);
|
|
|
|
}
|
|
|
|
testcase TC_ms_reg_enq() runs on test_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_start_handlers(refers(f_TC_ms_reg_enq), testcasename(), 22);
|
|
|
|
f_cleanup();
|
|
|
|
}
|
2020-12-09 14:10:55 +00:00
|
|
|
|
2021-01-16 20:56:17 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* RIM (RAN Information Management)
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
/* Our tests here are rather synthetic, as they don't reflect normal message flows
|
|
|
|
as they would be observed in a live network. However, for testing gbproxy, this shouldn't
|
|
|
|
matter as gbproxy is not concerned with anything but the source / destination routing
|
|
|
|
information */
|
|
|
|
|
|
|
|
/* gbproxy must route all unknown RIM Routing Info (Cell Id) to the SGSN. We just define
|
|
|
|
one here of which we know it is not used among the [simulated] PCUs */
|
|
|
|
const BssgpCellId cell_id_sgsn := {
|
|
|
|
ra_id := {
|
|
|
|
lai := {
|
|
|
|
mcc_mnc := c_mcc_mnc,
|
|
|
|
lac := 65534
|
|
|
|
},
|
|
|
|
rac := 0
|
|
|
|
},
|
|
|
|
cell_id := 65533
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Send 'tx' on PTP-BVCI from PCU; expect 'rx' on any of our SGSN (RIM can be routed anywhere) */
|
|
|
|
friend function f_rim_pcu2sgsn(template (value) PDU_BSSGP tx, template (present) PDU_BSSGP exp_rx,
|
|
|
|
integer pcu_idx := 0) runs on GlobalTest_CT {
|
|
|
|
var PDU_BSSGP rx;
|
2021-01-26 14:43:41 +00:00
|
|
|
timer T := 2.0;
|
2021-01-16 20:56:17 +00:00
|
|
|
|
|
|
|
RIM_PCU[pcu_idx].send(tx);
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[] any from RIM_SGSN.receive(exp_rx) {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
[] any from RIM_SGSN.receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Unexpected BSSGP on SGSN side: ", rx));
|
2021-01-16 20:56:17 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Timeout waiting for BSSGP on SGSN side: ", exp_rx));
|
2021-01-16 20:56:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send 'tx' on PTP-BVCI from SGSN; expect 'rx' on PCU */
|
|
|
|
friend function f_rim_sgsn2pcu(template (value) PDU_BSSGP tx, template (present) PDU_BSSGP exp_rx,
|
|
|
|
integer sgsn_idx := 0, integer pcu_idx := 0) runs on GlobalTest_CT {
|
|
|
|
var PDU_BSSGP rx;
|
2021-01-26 14:43:41 +00:00
|
|
|
timer T := 2.0;
|
2021-01-16 20:56:17 +00:00
|
|
|
|
|
|
|
RIM_SGSN[sgsn_idx].send(tx);
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[] RIM_PCU[pcu_idx].receive(exp_rx) {
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
[] RIM_PCU[pcu_idx].receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Unexpected BSSGP on PCU side: ", rx));
|
2021-01-16 20:56:17 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Timeout waiting for BSSGP on PCU side: ", exp_rx));
|
2021-01-16 20:56:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send 'tx' on PTP-BVCI from SRC-PCU; expect 'rx' on DST-PCU */
|
|
|
|
friend function f_rim_pcu2pcu(template (value) PDU_BSSGP tx, template (present) PDU_BSSGP exp_rx,
|
|
|
|
integer src_pcu_idx, integer dst_pcu_idx) runs on GlobalTest_CT {
|
|
|
|
var integer rx_idx;
|
|
|
|
var PDU_BSSGP rx;
|
2021-01-26 14:43:41 +00:00
|
|
|
timer T := 2.0;
|
2021-01-16 20:56:17 +00:00
|
|
|
|
|
|
|
RIM_PCU[src_pcu_idx].send(tx);
|
|
|
|
T.start;
|
|
|
|
alt {
|
|
|
|
[] RIM_PCU[dst_pcu_idx].receive(exp_rx) -> value rx{
|
|
|
|
setverdict(pass);
|
|
|
|
}
|
|
|
|
[] any from RIM_PCU.receive(exp_rx) -> @index value rx_idx {
|
|
|
|
setverdict(fail, "Received RIM on wrong PCU[", rx_idx ,"], expected on PCU[", dst_pcu_idx, "]");
|
|
|
|
}
|
|
|
|
[] any from RIM_SGSN.receive(exp_rx) {
|
|
|
|
setverdict(fail, "Received RIM on SGSN but expected it on other PCU");
|
|
|
|
}
|
|
|
|
[] any from RIM_SGSN.receive(PDU_BSSGP:?) -> value rx {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail, log2str("Unexpected BSSGP on SGSN side: ", rx));
|
2021-01-16 20:56:17 +00:00
|
|
|
}
|
|
|
|
[] T.timeout {
|
2021-01-27 09:50:24 +00:00
|
|
|
f_shutdown(__FILE__, __LINE__, fail,
|
|
|
|
log2str("Timeout waiting for BSSGP on SGSN side: ", exp_rx));
|
2021-01-16 20:56:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
type function rim_fn(integer sgsn_idx, integer pcu_idx, integer bvc_idx) runs on GlobalTest_CT;
|
|
|
|
|
|
|
|
/* helper function for the RIM test cases: Execute 'fn' for each BVC on each PCU for
|
|
|
|
each SGSN */
|
|
|
|
private function f_rim_iterator(rim_fn fn) runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, pcu_idx, bvc_idx;
|
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx+1) {
|
|
|
|
for (pcu_idx := 0; pcu_idx < lengthof(g_pcu); pcu_idx := pcu_idx+1) {
|
|
|
|
for (bvc_idx := 0; bvc_idx < lengthof(g_pcu[pcu_idx].cfg.bvc); bvc_idx := bvc_idx+1) {
|
|
|
|
log("Testing RIM SGSN[", sgsn_idx, "] <-> PCU[", pcu_idx, "][", bvc_idx, "]");
|
|
|
|
fn.apply(sgsn_idx, pcu_idx, bvc_idx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* RAN-INFORMATION-REQUEST */
|
|
|
|
private function f_TC_rim_info_req(integer sgsn_idx, integer pcu_idx, integer bvc_idx := 0)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var BssgpCellId cell_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id;
|
2021-01-28 20:43:16 +00:00
|
|
|
var template (value) RAN_Information_Request_RIM_Container cont_tx;
|
|
|
|
var template RAN_Information_Request_RIM_Container cont_rx;
|
|
|
|
var template RIM_Routing_Address ra_pcu;
|
|
|
|
var template RIM_Routing_Address ra_sgsn;
|
|
|
|
|
|
|
|
ra_pcu := t_RIM_Routing_Address_cid(cell_id);
|
|
|
|
ra_sgsn := t_RIM_Routing_Address_cid(cell_id_sgsn);
|
|
|
|
|
|
|
|
cont_tx := ts_RAN_Information_Request_RIM_Container(ts_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
ts_RIM_Sequence_Number(0),
|
|
|
|
ts_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP));
|
|
|
|
cont_rx := tr_RAN_Information_Request_RIM_Container(tr_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
tr_RIM_Sequence_Number(0),
|
|
|
|
tr_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP));
|
|
|
|
|
|
|
|
f_rim_pcu2sgsn(ts_RAN_INFORMATION_REQUEST(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_RAN_INFORMATION_REQUEST(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_rx),
|
|
|
|
pcu_idx);
|
|
|
|
|
|
|
|
f_rim_sgsn2pcu(ts_RAN_INFORMATION_REQUEST(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_RAN_INFORMATION_REQUEST(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_rx),
|
2021-01-16 20:56:17 +00:00
|
|
|
sgsn_idx, pcu_idx);
|
|
|
|
}
|
|
|
|
testcase TC_rim_info_req() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
f_rim_iterator(refers(f_TC_rim_info_req));
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* RAN-INFORMATION */
|
|
|
|
private function f_TC_rim_info(integer sgsn_idx, integer pcu_idx, integer bvc_idx := 0)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var BssgpCellId cell_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id;
|
2021-01-28 20:43:16 +00:00
|
|
|
var template (value) RAN_Information_RIM_Container cont_tx;
|
|
|
|
var template RAN_Information_RIM_Container cont_rx;
|
|
|
|
var template RIM_Routing_Address ra_pcu;
|
|
|
|
var template RIM_Routing_Address ra_sgsn;
|
|
|
|
|
|
|
|
ra_pcu := t_RIM_Routing_Address_cid(cell_id);
|
|
|
|
ra_sgsn := t_RIM_Routing_Address_cid(cell_id_sgsn);
|
|
|
|
|
|
|
|
cont_tx := ts_RAN_Information_RIM_Container(ts_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
ts_RIM_Sequence_Number(0),
|
|
|
|
ts_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP));
|
|
|
|
|
|
|
|
cont_rx := tr_RAN_Information_RIM_Container(tr_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
tr_RIM_Sequence_Number(0),
|
|
|
|
tr_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP));
|
|
|
|
|
|
|
|
f_rim_pcu2sgsn(ts_PDU_BSSGP_RAN_INFORMATION(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_rx),
|
|
|
|
pcu_idx);
|
|
|
|
|
|
|
|
f_rim_sgsn2pcu(ts_PDU_BSSGP_RAN_INFORMATION(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_rx),
|
2021-01-16 20:56:17 +00:00
|
|
|
sgsn_idx, pcu_idx);
|
|
|
|
}
|
|
|
|
testcase TC_rim_info() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
f_rim_iterator(refers(f_TC_rim_info));
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* RAN-INFORMATION-ACK */
|
|
|
|
private function f_TC_rim_info_ack(integer sgsn_idx, integer pcu_idx, integer bvc_idx := 0)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var BssgpCellId cell_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id;
|
2021-01-28 20:43:16 +00:00
|
|
|
var template (value) RAN_Information_Ack_RIM_Container cont_tx;
|
|
|
|
var template RAN_Information_Ack_RIM_Container cont_rx;
|
|
|
|
var template RIM_Routing_Address ra_pcu;
|
|
|
|
var template RIM_Routing_Address ra_sgsn;
|
|
|
|
|
|
|
|
ra_pcu := t_RIM_Routing_Address_cid(cell_id);
|
|
|
|
ra_sgsn := t_RIM_Routing_Address_cid(cell_id_sgsn);
|
|
|
|
|
|
|
|
cont_tx := ts_RAN_Information_Ack_RIM_Container(ts_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
ts_RIM_Sequence_Number(0));
|
|
|
|
|
|
|
|
cont_rx := tr_RAN_Information_Ack_RIM_Container(tr_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
tr_RIM_Sequence_Number(0));
|
|
|
|
|
|
|
|
f_rim_pcu2sgsn(ts_PDU_BSSGP_RAN_INFORMATION_ACK(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION_ACK(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_rx),
|
|
|
|
pcu_idx);
|
|
|
|
|
|
|
|
f_rim_sgsn2pcu(ts_PDU_BSSGP_RAN_INFORMATION_ACK(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION_ACK(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_rx),
|
2021-01-16 20:56:17 +00:00
|
|
|
sgsn_idx, pcu_idx);
|
|
|
|
}
|
|
|
|
testcase TC_rim_info_ack() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
f_rim_iterator(refers(f_TC_rim_info_ack));
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* RAN-INFORMATION-ERROR */
|
|
|
|
private function f_TC_rim_info_error(integer sgsn_idx, integer pcu_idx, integer bvc_idx := 0)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var BssgpCellId cell_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id;
|
2021-01-28 20:43:16 +00:00
|
|
|
var template (value) RAN_Information_Error_RIM_Container cont_tx;
|
|
|
|
var template RAN_Information_Error_RIM_Container cont_rx;
|
|
|
|
var template RIM_Routing_Address ra_pcu;
|
|
|
|
var template RIM_Routing_Address ra_sgsn;
|
|
|
|
|
|
|
|
ra_pcu := t_RIM_Routing_Address_cid(cell_id);
|
|
|
|
ra_sgsn := t_RIM_Routing_Address_cid(cell_id_sgsn);
|
|
|
|
|
|
|
|
cont_tx := ts_RAN_Information_Error_RIM_Container(ts_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
ts_BSSGP_CAUSE(BSSGP_CAUSE_EQUIMENT_FAILURE),
|
2021-02-05 12:05:06 +00:00
|
|
|
omit, valueof(ts_BVC_UNBLOCK(23)));
|
2021-01-28 20:43:16 +00:00
|
|
|
|
|
|
|
cont_rx := tr_RAN_Information_Error_RIM_Container(tr_RIM_Application_Identity(RIM_APP_ID_NACC),
|
2021-02-05 12:05:06 +00:00
|
|
|
ts_BSSGP_CAUSE(BSSGP_CAUSE_EQUIMENT_FAILURE),
|
|
|
|
omit, enc_PDU_BSSGP(valueof(tr_BVC_UNBLOCK(23))));
|
2021-01-28 20:43:16 +00:00
|
|
|
|
|
|
|
f_rim_pcu2sgsn(ts_PDU_BSSGP_RAN_INFORMATION_ERROR(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION_ERROR(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_rx),
|
|
|
|
pcu_idx);
|
|
|
|
|
|
|
|
f_rim_sgsn2pcu(ts_PDU_BSSGP_RAN_INFORMATION_ERROR(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION_ERROR(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_rx),
|
2021-01-16 20:56:17 +00:00
|
|
|
sgsn_idx, pcu_idx);
|
|
|
|
}
|
|
|
|
testcase TC_rim_info_error() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
f_rim_iterator(refers(f_TC_rim_info_error));
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-28 20:43:16 +00:00
|
|
|
//////////////////
|
2021-01-16 20:56:17 +00:00
|
|
|
/* RAN-INFORMATION-APPLICATION-ERROR */
|
|
|
|
private function f_TC_rim_info_app_error(integer sgsn_idx, integer pcu_idx, integer bvc_idx := 0)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var BssgpCellId cell_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id;
|
2021-01-28 20:43:16 +00:00
|
|
|
var template (value) Application_Error_Container app_cont_tx;
|
|
|
|
var template Application_Error_Container app_cont_rx;
|
|
|
|
var template (value) RAN_Information_Application_Error_RIM_Container cont_tx;
|
|
|
|
var template RAN_Information_Application_Error_RIM_Container cont_rx;
|
|
|
|
var template RIM_Routing_Address ra_pcu;
|
|
|
|
var template RIM_Routing_Address ra_sgsn;
|
|
|
|
|
|
|
|
ra_pcu := t_RIM_Routing_Address_cid(cell_id);
|
|
|
|
ra_sgsn := t_RIM_Routing_Address_cid(cell_id_sgsn);
|
|
|
|
|
|
|
|
app_cont_tx := tsu_Application_Error_Container_NACC(cell_id, 23,
|
|
|
|
tsu_Application_Container_IE_NACC_req(cell_id));
|
|
|
|
|
|
|
|
app_cont_rx := rsu_Application_Error_Container_NACC(cell_id, 23,
|
|
|
|
rsu_Application_Container_IE_NACC_req(cell_id));
|
|
|
|
|
|
|
|
cont_tx := ts_RAN_Information_Application_Error_RIM_Container(ts_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
ts_RIM_Sequence_Number(0),
|
|
|
|
ts_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP),
|
|
|
|
omit, app_cont_tx);
|
|
|
|
cont_rx := tr_RAN_Information_Application_Error_RIM_Container(tr_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
tr_RIM_Sequence_Number(0),
|
|
|
|
tr_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP),
|
|
|
|
omit, app_cont_rx);
|
|
|
|
|
|
|
|
f_rim_pcu2sgsn(ts_PDU_BSSGP_RAN_INFORMATION_APPLICATION_ERROR(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION_APPLICATION_ERROR(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_rx),
|
|
|
|
pcu_idx);
|
|
|
|
|
|
|
|
f_rim_sgsn2pcu(ts_PDU_BSSGP_RAN_INFORMATION_APPLICATION_ERROR(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION_APPLICATION_ERROR(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_sgsn),
|
|
|
|
cont := cont_rx),
|
2021-01-16 20:56:17 +00:00
|
|
|
sgsn_idx, pcu_idx);
|
|
|
|
}
|
|
|
|
testcase TC_rim_info_app_error() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
f_rim_iterator(refers(f_TC_rim_info_app_error));
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* RAN-INFORMATION routing directly between PCUs, without SGSN involvement */
|
|
|
|
private function f_TC_rim_info_pcu2pcu(integer src_pcu_idx, integer src_bvc_idx,
|
|
|
|
integer dst_pcu_idx, integer dst_bvc_idx)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var BssgpCellId cell_id_src := g_pcu[src_pcu_idx].cfg.bvc[src_bvc_idx].cell_id;
|
|
|
|
var BssgpCellId cell_id_dst := g_pcu[dst_pcu_idx].cfg.bvc[dst_bvc_idx].cell_id;
|
2021-02-10 17:25:50 +00:00
|
|
|
var template (value) RIM_Routing_Information ri_pcu_src_tx;
|
|
|
|
var template (value) RIM_Routing_Information ri_pcu_dst_tx;
|
|
|
|
var template RIM_Routing_Information ri_pcu_src_rx;
|
|
|
|
var template RIM_Routing_Information ri_pcu_dst_rx;
|
|
|
|
var template (value) RAN_Information_RIM_Container cont_tx;
|
|
|
|
var template RAN_Information_RIM_Container cont_rx;
|
2021-01-16 20:56:17 +00:00
|
|
|
|
|
|
|
log("Testing RIM PCU2PCU from PCU[", src_pcu_idx, "][", src_bvc_idx, "] to PCU[",
|
|
|
|
dst_pcu_idx, "][", dst_bvc_idx, "]");
|
|
|
|
|
2021-02-10 17:25:50 +00:00
|
|
|
ri_pcu_src_tx := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID,
|
|
|
|
t_RIM_Routing_Address_cid(cell_id_src));
|
|
|
|
ri_pcu_dst_tx := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID,
|
|
|
|
t_RIM_Routing_Address_cid(cell_id_dst));
|
|
|
|
ri_pcu_src_rx := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID,
|
2021-01-16 20:56:17 +00:00
|
|
|
t_RIM_Routing_Address_cid(cell_id_src));
|
2021-02-10 17:25:50 +00:00
|
|
|
ri_pcu_dst_rx := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID,
|
2021-01-16 20:56:17 +00:00
|
|
|
t_RIM_Routing_Address_cid(cell_id_dst));
|
2021-02-10 17:25:50 +00:00
|
|
|
|
|
|
|
cont_tx := ts_RAN_Information_RIM_Container(ts_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
ts_RIM_Sequence_Number(0),
|
|
|
|
ts_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP));
|
|
|
|
cont_rx := tr_RAN_Information_RIM_Container(tr_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
tr_RIM_Sequence_Number(0),
|
|
|
|
tr_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP));
|
|
|
|
|
|
|
|
f_rim_pcu2pcu(ts_PDU_BSSGP_RAN_INFORMATION(dst := ri_pcu_dst_tx, src := ri_pcu_src_tx, cont := cont_tx),
|
|
|
|
tr_PDU_BSSGP_RAN_INFORMATION(dst := ri_pcu_dst_rx, src := ri_pcu_src_rx, cont := cont_rx),
|
2021-01-16 20:56:17 +00:00
|
|
|
src_pcu_idx, dst_pcu_idx);
|
|
|
|
}
|
|
|
|
testcase TC_rim_info_pcu2pcu() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer src_pcu_idx, dst_pcu_idx;
|
|
|
|
var integer src_bvc_idx, dst_bvc_idx;
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
|
|
|
|
for (src_pcu_idx := 0; src_pcu_idx < lengthof(g_pcu); src_pcu_idx := src_pcu_idx + 1) {
|
|
|
|
for (src_bvc_idx := 0; src_bvc_idx < lengthof(g_pcu[src_pcu_idx].cfg.bvc); src_bvc_idx := src_bvc_idx + 1) {
|
|
|
|
for (dst_pcu_idx := 0; dst_pcu_idx < lengthof(g_pcu); dst_pcu_idx := dst_pcu_idx + 1) {
|
|
|
|
if (dst_pcu_idx == src_pcu_idx) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (dst_bvc_idx := 0; dst_bvc_idx < lengthof(g_pcu[dst_pcu_idx].cfg.bvc);
|
|
|
|
dst_bvc_idx := dst_bvc_idx + 1) {
|
|
|
|
f_TC_rim_info_pcu2pcu(src_pcu_idx, src_bvc_idx, dst_pcu_idx, dst_bvc_idx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-05-07 11:20:58 +00:00
|
|
|
|
|
|
|
/* Test RIM REQ sent from an MME->SGSN->GBPROXY->PCU and back (eNACC) */
|
|
|
|
private function f_TC_rim_from_eutran(integer sgsn_idx, integer pcu_idx, integer bvc_idx := 0)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var BssgpCellId cell_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id;
|
|
|
|
var template (value) RAN_Information_Request_RIM_Container cont_tx;
|
|
|
|
var template RAN_Information_Request_RIM_Container cont_rx;
|
|
|
|
var template RIM_Routing_Address ra_pcu;
|
|
|
|
var template RIM_Routing_Address ra_sgsn;
|
|
|
|
|
|
|
|
ra_pcu := t_RIM_Routing_Address_cid(cell_id);
|
|
|
|
ra_sgsn := t_RIM_Routing_Address_enbid(cell_id_sgsn, tac := 3, gnbid := '12345678123456'O);
|
|
|
|
|
|
|
|
cont_tx := ts_RAN_Information_Request_RIM_Container(ts_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
ts_RIM_Sequence_Number(0),
|
|
|
|
ts_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP));
|
|
|
|
cont_rx := tr_RAN_Information_Request_RIM_Container(tr_RIM_Application_Identity(RIM_APP_ID_NACC),
|
|
|
|
tr_RIM_Sequence_Number(0),
|
|
|
|
tr_RIM_PDU_Indications(false, RIM_PDU_TYPE_STOP));
|
|
|
|
|
|
|
|
f_rim_sgsn2pcu(ts_RAN_INFORMATION_REQUEST(dst := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_EUTRAN_NODEB_ID, ra_sgsn),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_RAN_INFORMATION_REQUEST(dst := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_EUTRAN_NODEB_ID, ra_sgsn),
|
|
|
|
cont := cont_rx),
|
|
|
|
sgsn_idx, pcu_idx);
|
|
|
|
|
|
|
|
|
|
|
|
f_rim_pcu2sgsn(ts_RAN_INFORMATION_REQUEST(dst := ts_RIM_Routing_Information(RIM_ADDR_EUTRAN_NODEB_ID, ra_sgsn),
|
|
|
|
src := ts_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_tx),
|
|
|
|
tr_RAN_INFORMATION_REQUEST(dst := tr_RIM_Routing_Information(RIM_ADDR_EUTRAN_NODEB_ID, ra_sgsn),
|
|
|
|
src := tr_RIM_Routing_Information(RIM_ADDR_GERAN_CELL_ID, ra_pcu),
|
|
|
|
cont := cont_rx),
|
|
|
|
pcu_idx);
|
|
|
|
}
|
|
|
|
testcase TC_rim_from_eutran() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
f_rim_iterator(refers(f_TC_rim_from_eutran));
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
2021-01-17 12:48:13 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* STATUS handling
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
/* BSSGP STATUS PDU must be routed based on inner "PDU In Error" message */
|
|
|
|
|
|
|
|
/* generate a TMSI with NRI matching sgsn_idx + nri_idx */
|
|
|
|
private function f_gen_tmsi_for_sgsn_nri(integer sgsn_idx, integer nri_idx) runs on test_CT return OCT4
|
|
|
|
{
|
|
|
|
var integer nri := mp_sgsn_nri[sgsn_idx][nri_idx];
|
|
|
|
return f_gen_tmsi(0, nri_v := nri, nri_bitlen := mp_nri_bitlength);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* generate a TLLI with NRI matching sgsn_idx + nri_idx */
|
|
|
|
private function f_gen_tlli_for_sgsn_nri(integer sgsn_idx, integer nri_idx) runs on test_CT return OCT4
|
|
|
|
{
|
|
|
|
var OCT4 p_tmsi := f_gen_tmsi_for_sgsn_nri(sgsn_idx, nri_idx);
|
|
|
|
return f_gprs_tlli_from_tmsi(p_tmsi, TLLI_LOCAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* STATUS in uplink direction; expect routing by its NRI */
|
|
|
|
private function f_TC_status_ul(integer pcu_idx, integer sgsn_idx, PDU_BSSGP inner)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var template (value) PDU_BSSGP tx := ts_BSSGP_STATUS(omit, BSSGP_CAUSE_EQUIMENT_FAILURE, inner);
|
|
|
|
var template (present) PDU_BSSGP exp_rx :=
|
|
|
|
tr_BSSGP_STATUS(omit, BSSGP_CAUSE_EQUIMENT_FAILURE,
|
|
|
|
tx.pDU_BSSGP_STATUS.pDU_in_Error.erroneous_BSSGP_PDU);
|
|
|
|
|
|
|
|
f_global_pcu2sgsn(tx, exp_rx, pcu_idx, sgsn_idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* STATUS in uplink direction; expect routing by its NRI */
|
|
|
|
private function f_TC_status_dl(integer sgsn_idx, integer pcu_idx, PDU_BSSGP inner)
|
|
|
|
runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var template (value) PDU_BSSGP tx := ts_BSSGP_STATUS(omit, BSSGP_CAUSE_EQUIMENT_FAILURE, inner);
|
|
|
|
var template (present) PDU_BSSGP exp_rx :=
|
|
|
|
tr_BSSGP_STATUS(omit, BSSGP_CAUSE_EQUIMENT_FAILURE,
|
|
|
|
tx.pDU_BSSGP_STATUS.pDU_in_Error.erroneous_BSSGP_PDU);
|
|
|
|
|
|
|
|
f_global_sgsn2pcu(tx, exp_rx, sgsn_idx, pcu_idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* STATUS in uplink direction on SIG-BVC containing a TLLI; expect routing by its NRI */
|
|
|
|
testcase TC_status_sig_ul_tlli() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, nri_idx;
|
|
|
|
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
|
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx + 1) {
|
|
|
|
for (nri_idx := 0; nri_idx < lengthof(mp_sgsn_nri[sgsn_idx]); nri_idx := nri_idx + 1) {
|
|
|
|
/* some downlink PDU occurring on SIG-BVC with a TLLI */
|
|
|
|
var OCT4 tlli := f_gen_tlli_for_sgsn_nri(sgsn_idx, nri_idx);
|
|
|
|
var PDU_BSSGP inner := valueof(ts_BSSGP_FLUSH_LL(tlli, 2342));
|
|
|
|
|
|
|
|
f_TC_status_ul(0, sgsn_idx, inner);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* STATUS in uplink direction on SIG-BVC containing a TMSI; expect routing by its NRI */
|
|
|
|
testcase TC_status_sig_ul_tmsi() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, nri_idx;
|
|
|
|
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
|
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx + 1) {
|
|
|
|
for (nri_idx := 0; nri_idx < lengthof(mp_sgsn_nri[sgsn_idx]); nri_idx := nri_idx + 1) {
|
|
|
|
/* some downlink PDU occurring on SIG-BVC with a TMSI */
|
|
|
|
const hexstring imsi := '001010123456789'H
|
|
|
|
var OCT4 tmsi := f_gen_tmsi_for_sgsn_nri(sgsn_idx, nri_idx);
|
|
|
|
var BssgpBvci bvci := g_pcu[0].cfg.bvc[0].bvci;
|
|
|
|
var PDU_BSSGP inner := valueof(ts_BSSGP_CS_PAGING_PTMSI(bvci, imsi, oct2int(tmsi)));
|
|
|
|
f_TC_status_ul(0, sgsn_idx, inner);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* STATUS in uplink direction on PTP-BVC containing a TLLI; expect routing by its NRI */
|
|
|
|
testcase TC_status_ptp_ul_tlli() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, nri_idx;
|
|
|
|
|
|
|
|
f_init();
|
|
|
|
f_global_init_ptp();
|
|
|
|
|
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx + 1) {
|
|
|
|
for (nri_idx := 0; nri_idx < lengthof(mp_sgsn_nri[sgsn_idx]); nri_idx := nri_idx + 1) {
|
|
|
|
/* some downlink PDU occurring on PTP-BVC with a TLLI */
|
|
|
|
var OCT4 tlli := f_gen_tlli_for_sgsn_nri(sgsn_idx, nri_idx);
|
|
|
|
var PDU_BSSGP inner := valueof(ts_BSSGP_DL_UD(tlli, '2342'O));
|
|
|
|
|
|
|
|
f_TC_status_ul(0, sgsn_idx, inner);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* STATUS in uplink direction on PTP-BVC containing a TMSI; expect routing by its NRI */
|
|
|
|
testcase TC_status_ptp_ul_tmsi() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, nri_idx;
|
|
|
|
|
|
|
|
f_init();
|
|
|
|
f_global_init_ptp();
|
|
|
|
|
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx + 1) {
|
|
|
|
for (nri_idx := 0; nri_idx < lengthof(mp_sgsn_nri[sgsn_idx]); nri_idx := nri_idx + 1) {
|
|
|
|
/* some downlink PDU occurring on PTP-BVC with a TMSI */
|
|
|
|
const hexstring imsi := '001010123456789'H
|
|
|
|
var OCT4 tmsi := f_gen_tmsi_for_sgsn_nri(sgsn_idx, nri_idx);
|
|
|
|
var BssgpBvci bvci := g_pcu[0].cfg.bvc[0].bvci;
|
|
|
|
var PDU_BSSGP inner := valueof(ts_BSSGP_CS_PAGING_PTMSI(bvci, imsi, oct2int(tmsi)));
|
|
|
|
f_TC_status_ul(0, sgsn_idx, inner);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* STATUS in downlink direction in SIG-BVC containing a BVCI; expect routing by it */
|
|
|
|
testcase TC_status_sig_dl_bvci() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, pcu_idx, bvc_idx;
|
|
|
|
|
|
|
|
f_init();
|
|
|
|
f_global_init();
|
|
|
|
|
|
|
|
/* test each BVC in each PCU from each SGSN */
|
|
|
|
for (pcu_idx := 0; pcu_idx < lengthof(g_pcu); pcu_idx := pcu_idx + 1) {
|
|
|
|
for (bvc_idx := 0; bvc_idx < lengthof(g_pcu[pcu_idx].cfg.bvc); bvc_idx := bvc_idx + 1) {
|
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx + 1) {
|
|
|
|
/* some uplink PDU occurring on SIG-BVC containing a BVCI */
|
|
|
|
var BssgpBvci bvci := g_pcu[pcu_idx].cfg.bvc[bvc_idx].bvci;
|
|
|
|
var PDU_BSSGP inner := valueof(ts_BSSGP_LLC_DISCARDED('12345678'O, 1, bvci, 23));
|
|
|
|
f_TC_status_dl(sgsn_idx, pcu_idx, inner);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* STATUS in downlink direction in PTP-BVC; expect routing by BVCI */
|
|
|
|
testcase TC_status_ptp_dl_bvci() runs on GlobalTest_CT
|
|
|
|
{
|
|
|
|
var integer sgsn_idx, pcu_idx, bvc_idx;
|
|
|
|
|
|
|
|
f_init();
|
|
|
|
f_global_init_ptp();
|
|
|
|
|
|
|
|
/* test each BVC in each PCU from each SGSN */
|
|
|
|
for (pcu_idx := 0; pcu_idx < lengthof(g_pcu); pcu_idx := pcu_idx + 1) {
|
|
|
|
for (bvc_idx := 0; bvc_idx < lengthof(g_pcu[pcu_idx].cfg.bvc); bvc_idx := bvc_idx + 1) {
|
|
|
|
var BssgpBvci bvci := g_pcu[pcu_idx].cfg.bvc[bvc_idx].bvci;
|
|
|
|
f_global_ptp_connect_pcu_bvci(pcu_idx, bvci);
|
|
|
|
for (sgsn_idx := 0; sgsn_idx < NUM_SGSN; sgsn_idx := sgsn_idx + 1) {
|
|
|
|
f_global_ptp_connect_sgsn_bvci(sgsn_idx, bvci);
|
|
|
|
|
|
|
|
/* some uplink PDU occurring on PTP-BVC */
|
|
|
|
var BssgpCellId cell_id := g_pcu[pcu_idx].cfg.bvc[bvc_idx].cell_id;
|
|
|
|
var PDU_BSSGP inner := valueof(ts_BSSGP_UL_UD('12345678'O, cell_id, '4223'O));
|
|
|
|
f_TC_status_dl(sgsn_idx, pcu_idx, inner);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
f_cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: test case for DL-STATUS(SUSPEND/RESUME) containing RA-ID; expect routing by RA-ID */
|
|
|
|
/* TODO: test case for UL-STATUS(PAGING-by-IMSI) after sending an actual PAGIN-by-IMSI in DL first */
|
2021-01-16 20:56:17 +00:00
|
|
|
|
2020-09-08 16:58:22 +00:00
|
|
|
control {
|
|
|
|
execute( TC_BVC_bringup() );
|
2020-11-15 20:45:49 +00:00
|
|
|
execute( TC_ul_unitdata() );
|
2021-05-28 13:05:41 +00:00
|
|
|
execute( TC_ul_unitdata_pool_failure() );
|
2020-11-15 22:27:27 +00:00
|
|
|
execute( TC_dl_unitdata() );
|
2020-11-16 08:16:17 +00:00
|
|
|
execute( TC_ra_capability() );
|
2020-11-16 18:53:26 +00:00
|
|
|
execute( TC_ra_capability_upd() );
|
2020-11-19 13:27:29 +00:00
|
|
|
execute( TC_radio_status() );
|
2021-01-17 10:15:28 +00:00
|
|
|
execute( TC_radio_status_tmsi() );
|
|
|
|
execute( TC_radio_status_imsi() );
|
2020-11-19 14:48:05 +00:00
|
|
|
execute( TC_suspend() );
|
2020-11-19 14:58:43 +00:00
|
|
|
execute( TC_resume() );
|
2020-11-27 21:37:23 +00:00
|
|
|
execute( TC_trace() );
|
2020-11-27 21:49:02 +00:00
|
|
|
execute( TC_llc_discarded() );
|
2020-11-28 15:11:11 +00:00
|
|
|
execute( TC_overload() );
|
2020-11-24 22:14:20 +00:00
|
|
|
execute( TC_bvc_block_ptp() );
|
|
|
|
execute( TC_bvc_unblock_ptp() );
|
2020-11-25 16:12:53 +00:00
|
|
|
execute( TC_bvc_reset_ptp_from_bss() );
|
2020-11-27 18:11:56 +00:00
|
|
|
execute( TC_bvc_reset_sig_from_bss() );
|
2020-11-25 16:12:53 +00:00
|
|
|
execute( TC_bvc_reset_ptp_from_sgsn() );
|
2020-11-27 18:11:56 +00:00
|
|
|
execute( TC_bvc_reset_sig_from_sgsn() );
|
2020-12-08 07:29:09 +00:00
|
|
|
if (mp_enable_bss_load_sharing) {
|
2020-11-18 11:16:59 +00:00
|
|
|
/* don't enable this by default, as we don't yet have any automatic test setup for FR with 4 NS-VC */
|
|
|
|
execute( TC_load_sharing_dl() );
|
|
|
|
}
|
2020-11-22 20:46:48 +00:00
|
|
|
|
|
|
|
/* PAGING-PS over PTP BVC */
|
|
|
|
execute( TC_paging_ps_ptp_bss() );
|
|
|
|
execute( TC_paging_ps_ptp_lac() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_ps_ptp_lac_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
execute( TC_paging_ps_ptp_rac() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_ps_ptp_rac_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
execute( TC_paging_ps_ptp_bvci() );
|
2021-01-16 12:04:40 +00:00
|
|
|
execute( TC_paging_ps_ptp_bvci_imsi() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_ps_ptp_bvci_unknown() );
|
2021-01-16 14:20:46 +00:00
|
|
|
execute( TC_paging_ps_reject_ptp_bvci() );
|
|
|
|
execute( TC_paging_ps_reject_ptp_bvci_imsi() );
|
2021-01-16 18:09:20 +00:00
|
|
|
execute( TC_dummy_paging_ps_ptp() );
|
2020-11-22 20:46:48 +00:00
|
|
|
|
|
|
|
/* PAGING-PS over SIG BVC */
|
|
|
|
execute( TC_paging_ps_sig_bss() );
|
|
|
|
execute( TC_paging_ps_sig_lac() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_ps_sig_lac_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
execute( TC_paging_ps_sig_rac() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_ps_sig_rac_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
execute( TC_paging_ps_sig_bvci() );
|
2021-01-16 12:04:40 +00:00
|
|
|
execute( TC_paging_ps_sig_bvci_imsi() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_ps_sig_bvci_unknown() );
|
2021-01-16 14:20:46 +00:00
|
|
|
execute( TC_paging_ps_reject_sig_bvci() );
|
|
|
|
execute( TC_paging_ps_reject_sig_bvci_imsi() );
|
2021-01-16 18:09:20 +00:00
|
|
|
execute( TC_dummy_paging_ps_sig() );
|
2020-11-22 20:46:48 +00:00
|
|
|
|
|
|
|
/* PAGING-CS over PTP BVC */
|
|
|
|
execute( TC_paging_cs_ptp_bss() );
|
|
|
|
execute( TC_paging_cs_ptp_lac() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_cs_ptp_lac_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
execute( TC_paging_cs_ptp_rac() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_cs_ptp_rac_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
execute( TC_paging_cs_ptp_bvci() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_cs_ptp_bvci_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
|
|
|
|
/* PAGING-CS over SIG BVC */
|
|
|
|
execute( TC_paging_cs_sig_bss() );
|
|
|
|
execute( TC_paging_cs_sig_lac() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_cs_sig_lac_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
execute( TC_paging_cs_sig_rac() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_cs_sig_rac_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
execute( TC_paging_cs_sig_bvci() );
|
2020-11-23 21:07:07 +00:00
|
|
|
execute( TC_paging_cs_sig_bvci_unknown() );
|
2020-11-22 20:46:48 +00:00
|
|
|
|
2021-01-16 20:56:17 +00:00
|
|
|
/* RAN Information Management */
|
|
|
|
execute( TC_rim_info_req() );
|
|
|
|
execute( TC_rim_info() );
|
|
|
|
execute( TC_rim_info_ack() );
|
|
|
|
execute( TC_rim_info_error() );
|
|
|
|
execute( TC_rim_info_app_error() );
|
|
|
|
execute( TC_rim_info_pcu2pcu() );
|
2021-05-07 11:20:58 +00:00
|
|
|
execute( TC_rim_from_eutran() );
|
2021-01-16 20:56:17 +00:00
|
|
|
|
2020-11-22 20:46:48 +00:00
|
|
|
|
2020-11-24 13:50:59 +00:00
|
|
|
execute( TC_flush_ll() );
|
2020-12-09 14:10:55 +00:00
|
|
|
execute( TC_fc_bvc() );
|
2020-12-09 15:50:12 +00:00
|
|
|
execute( TC_fc_ms() );
|
2021-01-16 17:57:49 +00:00
|
|
|
execute( TC_ms_reg_enq() );
|
2021-01-17 12:48:13 +00:00
|
|
|
|
|
|
|
/* Uplink STATUS */
|
|
|
|
execute( TC_status_sig_ul_tlli() );
|
|
|
|
execute( TC_status_sig_ul_tmsi() );
|
|
|
|
execute( TC_status_ptp_ul_tlli() );
|
|
|
|
execute( TC_status_ptp_ul_tmsi() );
|
|
|
|
|
|
|
|
/* Downlink STATUS */
|
|
|
|
execute( TC_status_sig_dl_bvci() );
|
|
|
|
execute( TC_status_ptp_dl_bvci() );
|
2020-09-08 16:58:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|