Change in osmo-ttcn3-hacks[master]: pcu: Refactor GPRS infrastructure to keep state and simplify tests

This is merely a historical archive of years 2008-2021, before the migration to mailman3.

A maintained and still updated list archive can be found at https://lists.osmocom.org/hyperkitty/list/gerrit-log@lists.osmocom.org/.

pespin gerrit-no-reply at lists.osmocom.org
Tue May 19 18:15:39 UTC 2020


pespin has uploaded this change for review. ( https://gerrit.osmocom.org/c/osmo-ttcn3-hacks/+/18370 )


Change subject: pcu: Refactor GPRS infrastructure to keep state and simplify tests
......................................................................

pcu: Refactor GPRS infrastructure to keep state and simplify tests

Before this patch, each test had to somehow keep state for all the
transactions needed. Now, most of the state is moved to generic GprsMS,
UlTbf and DlTbf structures, and APIs to maintain its state, as well as
function helpers to submit or receive messages from it. For now
specially the Tx side was improved, some of the Rx parts are left for
later and are still using the old APIs.

This will allow for more complex scenarios and more complex tests
running several MS.

All the tests were updated to use the new APIs, reworked when needed and
even totally rewritten in some cases since they were doing
inconsistent/wrong stuff from the point of view of what the scenarios
or code paths they were expected to test.

There's no test regressions except for TC_egprs_pkt_chan_req* family,
where new ifnrastructure is actually fixing a bug of the old
infrastructure and TTCN3 code (new and old) is yet not prepared for
that, making the test fail. It will be fixed in next commit.

Change-Id: Ib3fee37580f0ea0530a659dec83656799bf57288
---
M pcu/GPRS_Components.ttcn
M pcu/PCU_Tests.ttcn
M pcu/PCU_selftest.ttcn
3 files changed, 629 insertions(+), 644 deletions(-)



  git pull ssh://gerrit.osmocom.org:29418/osmo-ttcn3-hacks refs/changes/70/18370/1

diff --git a/pcu/GPRS_Components.ttcn b/pcu/GPRS_Components.ttcn
index cbb6cda..8d47d44 100644
--- a/pcu/GPRS_Components.ttcn
+++ b/pcu/GPRS_Components.ttcn
@@ -44,16 +44,76 @@
 import from Native_Functions all;
 import from SGSN_Components all;
 
+type record DlTbf {
+	GsmRrMessage rr_imm_ass,
+	PacketDlAssign	ass,
+	PacketDlAssignment rlcmac_ass,
+	uint5_t tfi,
+	AckNackDescription acknack_desc
+};
+
+type record UlTbf {
+	GsmRrMessage rr_imm_ass,
+	PacketUlAssign	ass,
+	PacketUlAssignment rlcmac_ass,
+	uint5_t		tfi,
+	uint14_t	bsn,
+	CodingScheme	tx_cs_mcs
+};
+
+type record GprsMS {
+	hexstring	imsi,
+	GprsTlli       tlli,
+	uint16_t	ra,
+	uint8_t		ra_is_11bit,
+	PCUIF_BurstType	burst_type,
+	TimingAdvance	ta,
+	int16_t		lqual_cb,
+	UlTbf		ul_tbf optional,
+	DlTbf		dl_tbf optional
+};
+type record of GprsMS GprsMSArray;
+
+template AckNackDescription t_AckNackDescription_init := {
+	final_ack := '0'B,
+	starting_seq_nr := 0,
+	receive_block_bitmap := '0000000000000000000000000000000000000000000000000000000000000000'B
+}
+
+/* One phase packet access (see 3GPP TS 44.018, table 9.1.8.1) */
+const BIT8 chan_req_def := '01111000'B;
+
+template (value) GprsMS t_GprsMS_def := {
+        imsi := f_gen_imsi(42),
+        tlli := '00000001'O,
+        ra := bit2int(chan_req_def),
+        ra_is_11bit := 0,
+        burst_type := BURST_TYPE_0,
+        ta := 0,
+        lqual_cb := 0,
+        ul_tbf := omit,
+        dl_tbf := omit
+};
+
 type component MS_BTS_IFACE_CT {
 	/* Virtual BTS component */
 	var RAW_PCU_BTS_CT vc_BTS;
 	/* Connection to the BTS component (one for now) */
 	port RAW_PCU_MSG_PT BTS;
 
+	/* Support only 1 ms for now */
+	var GprsMS g_ms[1];
+
 	/* Value at which Countdown Procedure starts. Announced by network (GPRS Cell Options as per TS 04.60 Chapter 12.24) */
 	var uint4_t g_bs_cv_max := 4;
 }
 
+function f_init_gprs_ms(template (value) GprsMS ms_params := t_GprsMS_def) runs on MS_BTS_IFACE_CT
+{
+	g_ms[0] := valueof(ms_params);
+}
+
+
 function f_shutdown(charstring file, integer line,
 		    boolean final := false)
 runs on MS_BTS_IFACE_CT {
@@ -74,10 +134,274 @@
 	mtc.stop;
 }
 
-template AckNackDescription t_AckNackDescription_init := {
-	final_ack := '0'B,
-	starting_seq_nr := 0,
-	receive_block_bitmap := '0000000000000000000000000000000000000000000000000000000000000000'B
+function f_ultbf_new_from_rr_imm_ass(in GsmRrMessage rr_imm_ass)
+runs on MS_BTS_IFACE_CT return UlTbf {
+	var UlTbf ul_tbf;
+
+	ul_tbf.rr_imm_ass := rr_imm_ass;
+
+	/* Make sure we received an UL TBF Assignment */
+	if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := false, rest := tr_IaRestOctets_ULAss(?)))) {
+		ul_tbf.ass := rr_imm_ass.payload.imm_ass.rest_octets.hh.pa.uldl.ass.ul;
+		log("Rx Uplink TBF assignment: ", ul_tbf.ass);
+		setverdict(pass);
+	} else {
+		setverdict(fail, "Failed to match UL TBF Assignment");
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	if (match(ul_tbf.ass, tr_PacketUlDynAssign)) {
+		ul_tbf.tfi := ul_tbf.ass.dynamic.tfi_assignment;
+	} else if (match(ul_tbf.ass, tr_PacketUlSglAssign)) {
+		/* Nothing to do here  yet */
+	}
+	ul_tbf.bsn := 0;
+	return ul_tbf;
+}
+
+/* TODO: get stuff from f_rx_rlcmac_dl_block_exp_pkt_ul_ass */
+function f_ultbf_new_from_rlcmac_ass(RlcmacDlBlock dl_block)
+runs on MS_BTS_IFACE_CT return UlTbf {
+	var UlTbf ul_tbf;
+
+	ul_tbf.tx_cs_mcs := f_rlcmac_dl_block_get_assigned_ul_cs_mcs(dl_block);
+
+	ul_tbf.rlcmac_ass := dl_block.ctrl.payload.u.ul_assignment;
+	ul_tbf.bsn := 0;
+	ul_tbf.tx_cs_mcs := f_rlcmac_dl_block_get_assigned_ul_cs_mcs(dl_block);
+	ul_tbf.tfi := f_rlcmac_dl_block_get_tfi(dl_block);
+	/* TODO: handle GlobalTfiOrTlli	 tfi_or_tlli from pkt_ul_ass */
+
+	/* TODO: support single block allocation */
+	if (match(dl_block, tr_RLCMAC_UL_PACKET_ASS_GPRS(?, tr_PktUlAssGprsDynamic(tr_DynamicAllocation(?))))) {
+		ul_tbf.tfi := dl_block.ctrl.payload.u.ul_assignment.gprs.dyn_block_alloc.ul_tfi_assignment;
+	}
+	if (match(dl_block, tr_RLCMAC_UL_PACKET_ASS_EGPRS(?, tr_PktUlAssEgprsDynamic(tr_DynamicAllocation(?))))) {
+		ul_tbf.tfi := dl_block.ctrl.payload.u.ul_assignment.egprs.dyn_block_alloc.ul_tfi_assignment;
+	}
+	return ul_tbf;
+}
+
+function f_dltbf_new_from_rr_imm_ass(in GsmRrMessage rr_imm_ass, template PacketDlAssign dl_ass := tr_PacketDlAssign(?))
+runs on MS_BTS_IFACE_CT return DlTbf {
+	var DlTbf dl_tbf;
+
+	dl_tbf.rr_imm_ass := rr_imm_ass;
+
+	/* Make sure we received a DL TBF Assignment */
+	if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := true, rest := ?))) {
+		dl_tbf.ass := rr_imm_ass.payload.imm_ass.rest_octets.hh.pa.uldl.ass.dl;
+		log("Rx Downlink TBF assignment: ", dl_tbf.ass);
+		setverdict(pass);
+	} else {
+		setverdict(fail, "Failed to match UL TBF Assignment");
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	/* TODO: match TLLI */
+	if (dl_tbf.ass.group1_present == '1'B) {
+		dl_tbf.tfi := dl_tbf.ass.group1.tfi_assignment;
+	} else {
+		setverdict(fail, "Immediate Assignment contains no DL TFI");
+		f_shutdown(__BFILE__, __LINE__);
+	}
+	dl_tbf.acknack_desc := valueof(t_AckNackDescription_init);
+	return dl_tbf;
+}
+
+/* TODO: get stuff from f_rx_rlcmac_dl_block_exp_pkt_ass */
+function f_dltbf_new_from_rlcmac_ass(RlcmacDlBlock dl_block)
+runs on MS_BTS_IFACE_CT return DlTbf {
+	var DlTbf dl_tbf;
+
+	dl_tbf.rlcmac_ass := dl_block.ctrl.payload.u.dl_assignment;
+	dl_tbf.tfi := f_rlcmac_dl_block_get_tfi(dl_block);
+	/* TODO: handle GlobalTfiOrTlli	 tfi_or_tlli from pkt_dl_ass */
+	dl_tbf.acknack_desc := valueof(t_AckNackDescription_init);
+	return dl_tbf;
+}
+
+function f_ms_use_ra(inout GprsMS ms, uint16_t ra, uint8_t ra_is_11bit := 0)
+runs on MS_BTS_IFACE_CT {
+	ms.ra_is_11bit := ra_is_11bit;
+	if (ra_is_11bit != 0) {
+		ms.burst_type := BURST_TYPE_1;
+		/* 3GPP TS 44.018, table 9.1.8.1, note 2b: Request Reference shall be set to 127
+		 * when Immediate Assignment is triggered by EGPRS Packet Channel Request. Here
+		 * we assume that 11 bit RA always contains EGPRS Packet Channel Request. */
+		ms.ra := ra;
+	} else {
+		ms.burst_type := BURST_TYPE_0;
+		ms.ra := ra;
+	}
+}
+
+function f_ms_set_lqual(inout GprsMS ms, uint16_t lqual_cb := 0)
+runs on MS_BTS_IFACE_CT {
+        ms.lqual_cb := lqual_cb;
+}
+
+function f_ms_set_ta(inout GprsMS ms, TimingAdvance ta := 0)
+runs on MS_BTS_IFACE_CT {
+        ms.ta := ta;
+}
+
+function f_ms_rx_imm_ass_ccch(inout GprsMS ms, template PCUIF_Sapi sapi := PCU_IF_SAPI_AGCH, template GsmRrMessage t_imm_ass := ?)
+runs on MS_BTS_IFACE_CT return GsmRrMessage {
+	var PCUIF_Message pcu_msg;
+	var GsmRrMessage rr_imm_ass;
+	var octetstring data;
+	timer T;
+
+	T.start(2.0);
+	alt {
+	[] BTS.receive(tr_PCUIF_DATA_REQ(bts_nr := 0, trx_nr := 0, ts_nr := 0,
+					 sapi := sapi, data := ?)) -> value pcu_msg {
+		/* On PCH the payload is prefixed with paging group (3 octets): skip it.
+		 * TODO: add an additional template parameter, so we can match it. */
+		if (pcu_msg.u.data_req.sapi == PCU_IF_SAPI_PCH) {
+			data := substr(pcu_msg.u.data_req.data, 3, pcu_msg.u.data_req.len - 3);
+		} else {
+			data := pcu_msg.u.data_req.data;
+		}
+
+		rr_imm_ass := dec_GsmRrMessage(data);
+		if (not match(rr_imm_ass, t_imm_ass)) {
+		        /* Not for us? Wait for more. */
+		        repeat;
+		}
+
+		log("Rx Immediate Assignment: ", rr_imm_ass);
+		f_pcuif_tx_data_cnf(pcu_msg);
+		setverdict(pass);
+		return rr_imm_ass;
+		}
+	[] BTS.receive { repeat; }
+	[] T.timeout {
+		setverdict(fail, "Timeout waiting for Immediate Assignment");
+		f_shutdown(__BFILE__, __LINE__);
+		}
+	}
+	return rr_imm_ass; /* make compiler happy */
+}
+
+function f_ms_rx_imm_ass_rlcmac(inout GprsMS ms, out uint32_t poll_fn, template RlcmacDlBlock t_imm_ass := tr_RLCMAC_DL_PACKET_ASS)
+runs on MS_BTS_IFACE_CT return RlcmacDlBlock {
+	var RlcmacDlBlock dl_block;
+	var uint32_t dl_fn;
+
+	f_rx_rlcmac_dl_block(dl_block, dl_fn);
+	if (not match(dl_block, t_imm_ass)) {
+		setverdict(fail, "Failed to match Packet Assignment:", t_imm_ass);
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	poll_fn := f_rrbp_ack_fn(dl_fn, dl_block.ctrl.mac_hdr.rrbp);
+
+	if (match(dl_block, tr_RLCMAC_UL_PACKET_ASS)) {
+	       ms.ul_tbf := f_ultbf_new_from_rlcmac_ass(dl_block);
+	       if (ms.ul_tbf.rlcmac_ass.identity.tlli.tlli != ms.tlli) {
+		       setverdict(fail, "Wrong TLLI ", ms.ul_tbf.rlcmac_ass.identity.tlli, " received vs exp ", ms.tlli);
+		       f_shutdown(__BFILE__, __LINE__);
+	       }
+	} else if (match(dl_block, tr_RLCMAC_DL_PACKET_ASS)) {
+		ms.dl_tbf := f_dltbf_new_from_rlcmac_ass(dl_block);
+		/* TODO: match tlli from ms.dl_tbf.ass_rlcmac with ms.tlli), or error */
+	} else {
+		setverdict(fail, "Should not happen:", dl_block);
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	return dl_block;
+}
+
+function f_ms_establish_ul_tbf(inout GprsMS ms, uint32_t fn := 1337)
+runs on MS_BTS_IFACE_CT {
+	var GsmRrMessage rr_imm_ass;
+
+	/* Send RACH.ind */
+	log("Sending RACH.ind on fn=", fn, " with RA=", ms.ra, ", TA=", ms.ta);
+	BTS.send(ts_PCUIF_RACH_IND(bts_nr := 0, trx_nr := 0, ts_nr := 0,
+				   ra := ms.ra, is_11bit := ms.ra_is_11bit,
+				   burst_type := ms.burst_type,
+				   fn := fn, arfcn := 871,
+				   qta := ms.ta * 4));
+
+	/* Expect Immediate (TBF) Assignment on TS0/AGCH */
+	rr_imm_ass := f_ms_rx_imm_ass_ccch(ms, PCU_IF_SAPI_AGCH,
+	                                   tr_IMM_TBF_ASS(false, ms.ra, fn));
+
+	ms.ul_tbf := f_ultbf_new_from_rr_imm_ass(rr_imm_ass);
+}
+
+function f_ms_establish_dl_tbf_ccch(inout GprsMS ms, template PCUIF_Sapi sapi := PCU_IF_SAPI_AGCH, template GsmRrMessage t_imm_ass := tr_IMM_TBF_ASS(true, ?, ?))
+runs on MS_BTS_IFACE_CT {
+	var GsmRrMessage rr_imm_ass;
+
+	rr_imm_ass := f_ms_rx_imm_ass_ccch(ms, sapi, t_imm_ass);
+	ms.dl_tbf := f_dltbf_new_from_rr_imm_ass(rr_imm_ass, tr_PacketDlAssign(ms.tlli));
+}
+
+/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
+function f_ms_tx_data_ind(inout GprsMS ms, octetstring data, uint32_t fn := 0)
+runs on MS_BTS_IFACE_CT {
+	var template RAW_PCU_EventParam ev_param := {tdma_fn := ? };
+	BTS.send(ts_PCUIF_DATA_IND(bts_nr := 0, trx_nr := 0, ts_nr := 7, block_nr := 0,
+				   sapi := PCU_IF_SAPI_PDTCH, data := data,
+				   fn := fn, arfcn := 871, lqual_cb := ms.lqual_cb));
+	if (fn != 0) {
+		ev_param := {tdma_fn := fn };
+	}
+	BTS.receive(tr_RAW_PCU_EV(TDMA_EV_PDTCH_BLOCK_SENT, ev_param));
+}
+
+function f_ms_tx_ul_block(inout GprsMS ms, template (value) RlcmacUlBlock ul_data, uint32_t fn := 0)
+runs on MS_BTS_IFACE_CT return integer {
+	var octetstring data;
+	var integer padding_len;
+	/* Encode the payload of DATA.ind */
+	data := enc_RlcmacUlBlock(valueof(ul_data));
+	padding_len := 23 - lengthof(data);
+	data := f_pad_oct(data, 23, '00'O); /* CS-1 */
+
+	/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
+	f_ms_tx_data_ind(ms, data, fn);
+	return padding_len;
+}
+
+function f_ms_tx_ul_data_block(inout GprsMS ms, octetstring payload, uint4_t cv := 15, boolean with_tlli := false, uint32_t fn := 0)
+runs on MS_BTS_IFACE_CT return integer {
+	var template (value) RlcmacUlBlock ul_data;
+	ul_data := t_RLCMAC_UL_DATA(tfi := ms.ul_tbf.tfi,
+				    cv := cv,
+				    bsn := ms.ul_tbf.bsn,
+				    blocks := {t_RLCMAC_LLCBLOCK(payload)});
+	if (with_tlli) {
+		ul_data.data.mac_hdr.tlli_ind := true;
+		ul_data.data.tlli := ms.tlli;
+	}
+	ms.ul_tbf.bsn := ms.ul_tbf.bsn + 1;
+	ms.ul_tbf.bsn := ms.ul_tbf.bsn mod 128; /* FIXME: EGPRS SNS: 2048 */
+	return f_ms_tx_ul_block(ms, ul_data, fn);
+
+}
+
+function f_ms_tx_ul_data_block_multi(inout GprsMS ms, integer num_blocks := 1, boolean with_tlli := false)
+runs on MS_BTS_IFACE_CT return octetstring {
+	var octetstring total_payload := ''O;
+
+	for (var integer i := 0; i < num_blocks; i := i + 1) {
+		var integer padding_len;
+		var octetstring payload := f_rnd_octstring(10);
+		/* Prepare a new UL block (CV, random payload) */
+		var integer cv := num_blocks - i - 1;
+		if (cv > g_bs_cv_max) {
+			cv := 15;
+		}
+		padding_len :=  f_ms_tx_ul_data_block(ms, payload, cv := cv, with_tlli := with_tlli)
+		total_payload := total_payload & payload & f_pad_oct(''O, padding_len, '00'O);
+	}
+	return total_payload;
 }
 
 function f_rlcmac_dl_block_get_tfi(RlcmacDlBlock dl_block)
@@ -93,6 +417,9 @@
 		if (match(dl_block, tr_RLCMAC_UL_PACKET_ASS_EGPRS(?, tr_PktUlAssEgprsDynamic(tr_DynamicAllocation(?))))) {
 			return dl_block.ctrl.payload.u.ul_assignment.egprs.dyn_block_alloc.ul_tfi_assignment;
 		}
+		if (match(dl_block, tr_RLCMAC_DL_PACKET_ASS(?))) {
+			return dl_block.ctrl.payload.u.dl_assignment.dl_tfi_assignment;
+		}
 	}
 	setverdict(fail, "DlBlock doesn't contain a TFI:", dl_block);
 	f_shutdown(__BFILE__, __LINE__);
@@ -169,120 +496,9 @@
 	BTS.send(pcu_msg_cnf);
 }
 
-function f_pcuif_rx_imm_ass(out GsmRrMessage rr_imm_ass,
-			    template PCUIF_Sapi sapi := PCU_IF_SAPI_AGCH,
-			    template GsmRrMessage t_imm_ass := ?,
-			    uint8_t bts_nr := 0)
-runs on MS_BTS_IFACE_CT return boolean {
-	var PCUIF_Message pcu_msg;
-	var octetstring data;
-	timer T;
-
-	T.start(2.0);
-	alt {
-	[] BTS.receive(tr_PCUIF_DATA_REQ(bts_nr := bts_nr, trx_nr := 0, ts_nr := 0,
-					 sapi := sapi, data := ?)) -> value pcu_msg {
-		/* On PCH the payload is prefixed with paging group (3 octets): skip it.
-		 * TODO: add an additional template parameter, so we can match it. */
-		if (pcu_msg.u.data_req.sapi == PCU_IF_SAPI_PCH) {
-			data := substr(pcu_msg.u.data_req.data, 3, pcu_msg.u.data_req.len - 3);
-		} else {
-			data := pcu_msg.u.data_req.data;
-		}
-
-		rr_imm_ass := dec_GsmRrMessage(data);
-		if (not match(rr_imm_ass, t_imm_ass)) {
-			/* Not for us? Wait for more. */
-			repeat;
-		}
-
-		log("Rx Immediate Assignment: ", rr_imm_ass);
-		setverdict(pass);
-		return true;
-		}
-	[] BTS.receive { repeat; }
-	[] T.timeout {
-		setverdict(fail, "Timeout waiting for Immediate Assignment");
-		}
-	}
-
-	return false;
-}
-
-/* One phase packet access (see 3GPP TS 44.018, table 9.1.8.1) */
-const BIT8 chan_req_def := '01111000'B;
-
-/* Establish an Uplink TBF by sending RACH.ind towards the PCU */
-function f_establish_tbf(out GsmRrMessage rr_imm_ass, uint8_t bts_nr := 0,
-			 uint16_t ra := bit2int(chan_req_def),
-			 uint8_t is_11bit := 0,
-			 PCUIF_BurstType burst_type := BURST_TYPE_0,
-			 TimingAdvance ta := 0)
-runs on MS_BTS_IFACE_CT return boolean {
-	var uint32_t fn;
-
-	/* FIXME: ask the BTS component to give us the current TDMA fn */
-	fn := 1337 + ta;
-
-	/* Send RACH.ind */
-	log("Sending RACH.ind on fn=", fn, " with RA=", ra, ", TA=", ta);
-	BTS.send(ts_PCUIF_RACH_IND(bts_nr := bts_nr, trx_nr := 0, ts_nr := 0,
-				   ra := ra, is_11bit := is_11bit,
-				   burst_type := burst_type,
-				   fn := fn, arfcn := 871,
-				   qta := ta * 4));
-
-	/* 3GPP TS 44.018, table 9.1.8.1, note 2b: Request Reference shall be set to 127
-	 * when Immediate Assignment is triggered by EGPRS Packet Channel Request. Here
-	 * we assume that 11 bit RA always contains EGPRS Packet Channel Request. */
-	if (is_11bit != 0) { ra := 127; }
-
-	/* Expect Immediate (TBF) Assignment on TS0/AGCH */
-	return f_pcuif_rx_imm_ass(rr_imm_ass, PCU_IF_SAPI_AGCH,
-				  tr_IMM_TBF_ASS(false, ra, fn),
-				  bts_nr := bts_nr);
-}
-
-function f_imm_ass_verify_ul_tbf_ass(in GsmRrMessage rr_imm_ass, out PacketUlAssign ul_tbf_ass, template PacketUlAssign ul_ass := tr_PacketUlDynAssign)
-runs on MS_BTS_IFACE_CT {
-
-	/* Make sure we received an UL TBF Assignment */
-	if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := false, rest := tr_IaRestOctets_ULAss(ul_ass)))) {
-		ul_tbf_ass := rr_imm_ass.payload.imm_ass.rest_octets.hh.pa.uldl.ass.ul;
-		log("Rx Uplink TBF assignment: ", ul_tbf_ass);
-		setverdict(pass);
-	} else {
-		setverdict(fail, "Failed to match UL TBF Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-}
-
-function f_imm_ass_verify_dl_tbf_ass(in GsmRrMessage rr_imm_ass, out PacketDlAssign dl_tbf_ass)
-runs on MS_BTS_IFACE_CT {
-
-	/* Make sure we received a DL TBF Assignment */
-	if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := true, rest := tr_IaRestOctets_DLAss(?)))) {
-		dl_tbf_ass := rr_imm_ass.payload.imm_ass.rest_octets.hh.pa.uldl.ass.dl;
-		log("Rx Downlink TBF assignment: ", dl_tbf_ass);
-		setverdict(pass);
-	} else {
-		setverdict(fail, "Failed to match DL TBF Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-}
-
-/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-function f_pcuif_tx_data_ind(octetstring data, int16_t lqual_cb := 0, uint32_t fn := 0)
-runs on MS_BTS_IFACE_CT {
-	var template RAW_PCU_EventParam ev_param := {tdma_fn := ? };
-	BTS.send(ts_PCUIF_DATA_IND(bts_nr := 0, trx_nr := 0, ts_nr := 7, block_nr := 0,
-				   sapi := PCU_IF_SAPI_PDTCH, data := data,
-				   fn := fn, arfcn := 871, lqual_cb := lqual_cb));
-	if (fn != 0) {
-		ev_param := {tdma_fn := fn };
-	}
-	BTS.receive(tr_RAW_PCU_EV(TDMA_EV_PDTCH_BLOCK_SENT, ev_param));
-}
+////////////////////////
+// OLD APIs
+////////////////////////
 
 /* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
 function f_pcuif_rx_data_req(out PCUIF_Message pcu_msg)
@@ -294,23 +510,6 @@
 				      sapi := PCU_IF_SAPI_PDTCH)) -> value pcu_msg;
 }
 
-/* Expect an Immediate Assignment (paging) from PCU on PCUIF on specified sapi.  */
-function f_pcuif_rx_pch_imm_tbf_ass(out GsmRrMessage rr_imm_ass)
-runs on MS_BTS_IFACE_CT {
-	var PCUIF_Message pcu_msg;
-	var octetstring macblock;
-	BTS.receive(tr_PCUIF_DATA_REQ(bts_nr := 0, trx_nr := 0, ts_nr := 0,
-				      sapi := PCU_IF_SAPI_PCH)) -> value pcu_msg;
-	/* First 3 bytes contain paging group: */
-	macblock := substr(pcu_msg.u.data_req.data, 3, pcu_msg.u.data_req.len - 3);
-	rr_imm_ass := dec_GsmRrMessage(macblock);
-	if (not match(rr_imm_ass, tr_IMM_TBF_ASS())) {
-		setverdict(fail, "Failed to match Immediate Assignment: ", rr_imm_ass);
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	f_pcuif_tx_data_cnf(pcu_msg);
-}
-
 /* Expect a Paging Request Type 1 from PCU on PCUIF on specified sapi.  */
 function f_pcuif_rx_pch_pag_req1(template MobileIdentityV mi1 := ?,
 				 template integer pag_group := ?)
@@ -348,56 +547,6 @@
 	return rr_pag_req1;
 }
 
-/* Send one rlcmac UL block adding necessary extra padding at the end.
- * returns length of extra padding added at the end, in octets.
- *  FIXME: Only supports CS-1 so far.
- */
-function f_tx_rlcmac_ul_block(template (value) RlcmacUlBlock ul_data, int16_t lqual_cb := 0, uint32_t fn := 0)
-runs on MS_BTS_IFACE_CT return integer {
-	var octetstring data;
-	var integer padding_len;
-	/* Encode the payload of DATA.ind */
-	data := enc_RlcmacUlBlock(valueof(ul_data));
-	padding_len := 23 - lengthof(data);
-	data := f_pad_oct(data, 23, '00'O); /* CS-1 */
-
-	/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-	f_pcuif_tx_data_ind(data, lqual_cb, fn);
-	return padding_len;
-}
-
-function f_tx_rlcmac_ul_n_blocks(uint5_t tfi, inout uint14_t bsn, integer num_blocks := 1, template (omit) GprsTlli tlli := omit)
-runs on MS_BTS_IFACE_CT return octetstring {
-	var octetstring total_payload := ''O;
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA(
-		tfi := tfi,
-		cv := 15, /* num UL blocks to be sent (to be overridden in loop) */
-		bsn := 0, /* To be generated in loop */
-		blocks := { /* To be generated in loop */ });
-
-	if (not istemplatekind(tlli, "omit")) {
-		ul_data.data.mac_hdr.tlli_ind := true;
-		ul_data.data.tlli := tlli;
-	}
-
-	for (var integer i := 0; i < num_blocks; i := i + 1) {
-		var integer padding_len;
-		var octetstring payload := f_rnd_octstring(10);
-		/* Prepare a new UL block (CV, random payload) */
-		var integer cv := num_blocks - i - 1;
-		if (cv > g_bs_cv_max) {
-			cv := 15;
-		}
-		ul_data.data.mac_hdr.countdown := cv;
-		ul_data.data.mac_hdr.bsn := bsn + i;
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(payload)) };
-		padding_len := f_tx_rlcmac_ul_block(ul_data);
-		total_payload := total_payload & payload & f_pad_oct(''O, padding_len, '00'O);
-	}
-	bsn := valueof(ul_data.data.mac_hdr.bsn) + 1; /* update bsn to point to next one */
-	return total_payload;
-}
-
 function f_rx_rlcmac_dl_block(out RlcmacDlBlock dl_block, out uint32_t dl_fn, template (present) CodingScheme exp_cs_mcs := ?)
 runs on MS_BTS_IFACE_CT {
 	var PCUIF_Message pcu_msg;
@@ -438,46 +587,6 @@
 	}
 }
 
-function f_rx_rlcmac_dl_block_exp_pkt_ass(out RlcmacDlBlock dl_block, out uint32_t poll_fn)
-runs on MS_BTS_IFACE_CT {
-	var uint32_t dl_fn;
-
-	f_rx_rlcmac_dl_block(dl_block, dl_fn);
-	if (not match(dl_block, tr_RLCMAC_DL_PACKET_ASS())) {
-		setverdict(fail, "Failed to match Packet Downlink Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	poll_fn := f_rrbp_ack_fn(dl_fn, dl_block.ctrl.mac_hdr.rrbp);
-}
-
-function f_rx_rlcmac_dl_block_exp_pkt_ul_ass(out RlcmacDlBlock dl_block, out uint32_t poll_fn)
-runs on MS_BTS_IFACE_CT {
-        var uint32_t dl_fn;
-
-        f_rx_rlcmac_dl_block(dl_block, dl_fn);
-        if (not match(dl_block, tr_RLCMAC_UL_PACKET_ASS())) {
-                setverdict(fail, "Failed to match Packet Uplink Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-        }
-
-	poll_fn := f_rrbp_ack_fn(dl_fn, dl_block.ctrl.mac_hdr.rrbp);
-}
-
-function f_rx_rlcmac_dl_block_exp_pkt_dl_ass(out RlcmacDlBlock dl_block, out uint32_t poll_fn)
-runs on MS_BTS_IFACE_CT {
-        var uint32_t dl_fn;
-
-        f_rx_rlcmac_dl_block(dl_block, dl_fn);
-        if (not match(dl_block, tr_RLCMAC_DL_PACKET_ASS())) {
-                setverdict(fail, "Failed to match Packet Downlink Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-        }
-
-	poll_fn := f_rrbp_ack_fn(dl_fn, dl_block.ctrl.mac_hdr.rrbp);
-}
-
-
 function f_rx_rlcmac_dl_block_exp_pkt_pag_req(out RlcmacDlBlock dl_block)
 runs on MS_BTS_IFACE_CT {
 	var uint32_t dl_fn;
diff --git a/pcu/PCU_Tests.ttcn b/pcu/PCU_Tests.ttcn
index 22e3c1f..358d974 100644
--- a/pcu/PCU_Tests.ttcn
+++ b/pcu/PCU_Tests.ttcn
@@ -253,9 +253,11 @@
 /* Test of correct Timing Advance at the time of TBF establishment
  * (derived from timing offset of the Access Burst). */
 testcase TC_ta_rach_imm_ass() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_msg;
-	var boolean ok;
+	var GprsMS ms;
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
@@ -263,16 +265,13 @@
 	 * at some point the PCU will fail to allocate a new TBF. */
 	for (var TimingAdvance ta := 0; ta < 64; ta := ta + 16) {
 		/* Establish an Uplink TBF (send RACH.ind with current TA) */
-		ok := f_establish_tbf(rr_msg, bts_nr := 0, ta := ta);
-		if (not ok) {
-			setverdict(fail, "Failed to establish an Uplink TBF");
-			break;
-		}
+		f_ms_set_ta(ms, ta);
+		f_ms_establish_ul_tbf(ms, fn := 1337 + ta);
 
 		/* Make sure Timing Advance IE matches out expectations */
-		if (rr_msg.payload.imm_ass.timing_advance != ta) {
+		if (ms.ul_tbf.rr_imm_ass.payload.imm_ass.timing_advance != ta) {
 			setverdict(fail, "Timing Advance mismatch: ",
-				   rr_msg.payload.imm_ass.timing_advance,
+				   ms.ul_tbf.rr_imm_ass.payload.imm_ass.timing_advance,
 				   " vs expected ", ta);
 			break;
 		}
@@ -286,30 +285,29 @@
  * IUT that causes it to send an unreasonable Timing Advance value > 0 despite
  * no active TBF exists at the moment of establishment (idle mode). */
 testcase TC_ta_idle_dl_tbf_ass() runs on RAW_PCU_Test_CT {
-	var OCT4 tlli := f_rnd_octstring(4);
-	var GsmRrMessage rr_imm_ass;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will initiate Packet Downlink
 	 * Assignment on CCCH (PCH). We don't care about the payload. */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, f_rnd_octstring(10)));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass); // TODO: match by TLLI!
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, f_rnd_octstring(10)));
 
 	/* Make sure that Timing Advance is 0 (the actual value is not known yet).
 	 * As per 3GPP S 44.018, section 3.5.3.1.2, the network *shall* initiate
 	 * the procedures defined in 3GPP TS 44.060 or use the polling mechanism. */
-	if (not match(rr_imm_ass, tr_IMM_TBF_ASS(ta := 0))) {
-		setverdict(fail, "Timing Advance value doesn't match");
-	}
+	f_ms_rx_imm_ass_ccch(ms,  PCU_IF_SAPI_PCH, tr_IMM_TBF_ASS(ta := 0));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -460,9 +458,11 @@
 
 testcase TC_ta_ptcch_ul_multi_tbf() runs on RAW_PCU_Test_CT {
 	var template PacketUlAssign t_ul_tbf_ass;
-	var PacketUlAssign ul_tbf_ass[7];
-	var GsmRrMessage rr_msg[7];
-	var boolean ok;
+	var GprsMS ms;
+
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
@@ -472,30 +472,18 @@
 
 	/* Establish 7 Uplink TBFs (USF flag is 3 bits long, '111'B is reserved) */
 	for (var integer i := 0; i < 7; i := i + 1) {
-		ok := f_establish_tbf(rr_msg[i], ta := 0);
-		if (not ok) {
-			setverdict(fail, "Failed to establish an Uplink TBF #", i);
-			break;
-		}
-
-		/* Make sure we received an UL TBF Assignment */
-		if (match(rr_msg[i], tr_IMM_TBF_ASS(dl := false, rest := tr_IaRestOctets_ULAss(?)))) {
-			ul_tbf_ass[i] := rr_msg[i].payload.imm_ass.rest_octets.hh.pa.uldl.ass.ul;
-			log("Rx Uplink TBF assignment for #", i, ": ", ul_tbf_ass[i]);
-		} else {
-			setverdict(fail, "Failed to match UL TBF Assignment for #", i);
-			break;
-		}
+		/* Establish an Uplink TBF */
+		f_ms_establish_ul_tbf(ms);
 
 		/* We expect incremental TFI/USF assignment (dynamic allocation) */
 		t_ul_tbf_ass := tr_PacketUlDynAssign(tfi := i, usf := i);
-		if (not match(ul_tbf_ass[i], t_ul_tbf_ass)) {
+		if (not match(ms.ul_tbf.ass, t_ul_tbf_ass)) {
 			setverdict(fail, "Failed to match Packet Uplink Assignment for #", i);
 			break;
 		}
 
 		/* We also expect Timing Advance Index to be a part of the assignment */
-		if (ul_tbf_ass[i].dynamic.ta_index != i) {
+		if (ms.ul_tbf.ass.dynamic.ta_index != i) {
 			setverdict(fail, "Failed to match Timing Advance Index for #", i);
 			/* Keep going, the current OsmoPCU does not assign TA Index */
 		}
@@ -540,13 +528,14 @@
 private template integer CS4_lqual_dB_range := (12 .. infinity);
 
 testcase TC_cs_lqual_ul_tbf() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
-	var octetstring data;
-	var boolean ok;
-	var uint32_t unused_fn;
+	var GprsMS ms;
+	var uint32_t unused_fn, sched_fn;
+	var uint4_t cv;
+
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
@@ -555,47 +544,51 @@
 	f_pcuvty_set_link_quality_ranges();
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_establish_ul_tbf(ms);
 
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
-
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA(
-		tfi := ul_tbf_ass.dynamic.tfi_assignment,
-		cv := 15, /* 16 UL blocks to be sent (to be overridden in loop) */
-		bsn := 0, /* TODO: what should be here? */
-		blocks := { /* To be generated in loop */ });
-
-	/* HACK: patch missing TLLI; otherwise OsmoPCU rejects DATA.req */
-	ul_data.data.tlli := '00000001'O;
 
 	/* The actual / old link quality values. We need to keep track of the old
 	 * (basically previous) link quality value, because OsmoPCU actually
 	 * changes the coding scheme if not only the actual, but also the old
 	 * value leaves the current link quality range (window). */
-	var integer lqual := 0;
 	var integer lqual_old;
+	f_ms_set_lqual(ms, 0);
 
-	/* 16 UL blocks (0 .. 15 dB, step = 1 dB) */
-	for (var integer i := 0; i < 16; i := i + 1) {
-		/* Prepare a new UL block (CV, random payload) */
-		ul_data.data.mac_hdr.countdown := (15 - i);
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(f_rnd_octstring(10))) };
+	/* Send one UL block (with TLLI since we are in One-Phase Access
+	   contention resoultion) and make sure it is ACKED fine. */
+	/* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
+	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(16), cv := 15, with_tlli := true)
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
+	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
+	/* 16 UL blocks (0 .. 15 dB, step = 1 cB) */
+	for (var integer i := 150; i >= 0; i := i - 1) {
 		/* Update the old / actual link quality */
-		lqual_old := lqual;
-		lqual := i;
+		lqual_old := ms.lqual_cb;
+		f_ms_set_lqual(ms, 150 - i);
 
 		/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-		log("Sending DATA.ind with link quality (dB): ", lqual);
-		f_tx_rlcmac_ul_block(ul_data, lqual * 10);
+		log("Sending DATA.ind with link quality (dB): ", ms.lqual_cb);
+		if (i > g_bs_cv_max) {
+			cv := 15;
+		} else {
+			cv := i;
+		}
 
-		/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
-		f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
+		f_ms_tx_ul_data_block(ms, f_rnd_octstring(10), cv := cv)
+
+		/* we will receive UL ACK/NACK from time to time. In that case, check CdCofing increases */
+		f_rx_rlcmac_dl_block(dl_block, unused_fn);
+		if (match(dl_block, tr_RLCMAC_DUMMY_CTRL())) {
+			continue;
+		}
+		if (not match(dl_block, tr_RLCMAC_UL_ACK_NACK_GPRS(ul_tfi := ?)) and
+		    not match(dl_block, tr_RLCMAC_UL_ACK_NACK_EGPRS(ul_tfi := ?))) {
+			setverdict(fail, "Failed to match Packet Uplink ACK / NACK:", dl_block);
+			f_shutdown(__BFILE__, __LINE__);
+		}
 
 		log("Rx Packet Uplink ACK / NACK with Channel Coding Command: ",
 		    dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd);
@@ -604,7 +597,7 @@
 		 * the link quality value on each iteration and not decreasing, there
 		 * is no need to check the both old and current link quality values. */
 		var template ChCodingCommand ch_coding;
-		select (lqual_old) {
+		select (lqual_old / 10) {
 		case (CS1_lqual_dB_range) { ch_coding := CH_CODING_CS1; }
 		case (CS2_lqual_dB_range) { ch_coding := CH_CODING_CS2; }
 		case (CS3_lqual_dB_range) { ch_coding := CH_CODING_CS3; }
@@ -613,6 +606,7 @@
 
 		if (not match(dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd, ch_coding)) {
 			setverdict(fail, "Channel Coding does not match our expectations: ", ch_coding);
+			f_shutdown(__BFILE__, __LINE__);
 		}
 	}
 
@@ -621,13 +615,14 @@
 
 /* Test the max UL CS set by VTY works fine */
 testcase TC_cs_initial_ul() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
-	var integer lqual_cb;
 	var ChCodingCommand last_ch_coding;
-	var uint32_t unused_fn;
+	var uint32_t unused_fn, sched_fn;
+	var GprsMS ms;
+
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
@@ -638,65 +633,56 @@
 	f_pcuvty_set_link_quality_ranges();
 
 	/* Take lqual (dB->cB) so that we stay in that CS */
-	lqual_cb := g_cs_lqual_ranges[2].low * 10;
+	f_ms_set_lqual(ms, g_cs_lqual_ranges[2].low * 10);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_establish_ul_tbf(ms);
 
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	/* Send one UL block (with TLLI since we are in One-Phase Access
+	   contention resoultion) and make sure it is ACKED fine. */
+	/* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
+	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(16), cv := 15, with_tlli := true)
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
+	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA(
-		tfi := ul_tbf_ass.dynamic.tfi_assignment,
-		cv := 3, /* 8 UL blocks to be sent (to be overridden in loop) */
-		bsn := 0, /* TODO: what should be here? */
-		blocks := { /* To be generated in loop */ });
+	/* Send UL blocks, until we receive UL ACK/NACK and check we are in same initial CS: */
+	while (true) {
+		f_ms_tx_ul_data_block(ms, f_rnd_octstring(10), cv := 15);
+		f_rx_rlcmac_dl_block(dl_block, unused_fn);
+		if (match(dl_block, tr_RLCMAC_DUMMY_CTRL())) {
+			continue;
+		}
 
-	/* HACK: patch missing TLLI; otherwise OsmoPCU rejects DATA.req */
-	ul_data.data.tlli := '00000001'O;
+		if (not match(dl_block, tr_RLCMAC_UL_ACK_NACK_GPRS(ul_tfi := ?)) and
+		    not match(dl_block, tr_RLCMAC_UL_ACK_NACK_EGPRS(ul_tfi := ?))) {
+			setverdict(fail, "Failed to match Packet Uplink ACK / NACK:", dl_block);
+			f_shutdown(__BFILE__, __LINE__);
+			break;
+		}
 
-	/* 3 UL blocks, check we are in same initial CS: */
-	for (var integer i := 0; i < 3; i := i + 1) {
-		/* Prepare a new UL block (CV, random payload) */
-		ul_data.data.mac_hdr.countdown := (7 - i);
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(f_rnd_octstring(10))) };
-
-		/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-		f_tx_rlcmac_ul_block(ul_data, lqual_cb);
-
-		/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
-		f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
 		last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
+		break;
 	}
-
 	if (last_ch_coding != CH_CODING_CS3) {
 		setverdict(fail, "Channel Coding does not match our expectations (CS-3): ", last_ch_coding);
+		f_shutdown(__BFILE__, __LINE__);
 	}
 
 	/* Remaining UL blocks are used to make sure regardless of initial
 	/* lqual, we can go lower at any time */
-
+	 /* 0 dB, make sure we downgrade CS */
+	f_ms_set_lqual(ms, 0);
 	/* 5 UL blocks, check we are in same initial CS: */
-	for (var integer i := 3; i < 8; i := i + 1) {
-		/* Prepare a new UL block (CV, random payload) */
-		ul_data.data.mac_hdr.countdown := (7 - i);
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(f_rnd_octstring(10))) };
-
-		/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-		f_tx_rlcmac_ul_block(ul_data, 0); /* 0 dB, make sure we downgrade CS */
-
-		/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
-		f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
-
-		last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
-	}
+	f_ms_tx_ul_data_block_multi(ms, 5);
+	/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
+	last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
 
 	if (last_ch_coding != CH_CODING_CS1) {
 		setverdict(fail, "Channel Coding does not match our expectations (CS-1): ", last_ch_coding);
+		f_shutdown(__BFILE__, __LINE__);
 	}
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
@@ -704,12 +690,14 @@
 
 /* Test the max UL CS set by VTY works fine */
 testcase TC_cs_max_ul() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
 	var ChCodingCommand last_ch_coding;
-	var uint32_t unused_fn;
+	var uint32_t unused_fn, sched_fn;
+	var GprsMS ms;
+
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
@@ -720,41 +708,26 @@
 	f_pcuvty_set_link_quality_ranges();
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_establish_ul_tbf(ms);
 
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	/* Send one UL block (with TLLI since we are in One-Phase Access
+	   contention resoultion) and make sure it is ACKED fine. */
+	/* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
+	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(16), cv := 15, with_tlli := true)
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
+	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA(
-		tfi := ul_tbf_ass.dynamic.tfi_assignment,
-		cv := 15, /* 16 UL blocks to be sent (to be overridden in loop) */
-		bsn := 0, /* TODO: what should be here? */
-		blocks := { /* To be generated in loop */ });
+	f_ms_set_lqual(ms, 40*10); /* 40 dB */
+	f_ms_tx_ul_data_block_multi(ms, 16);
 
-	/* HACK: patch missing TLLI; otherwise OsmoPCU rejects DATA.req */
-	ul_data.data.tlli := '00000001'O;
-
-	/* 16 UL blocks */
-	for (var integer i := 0; i < 16; i := i + 1) {
-		/* Prepare a new UL block (CV, random payload) */
-		ul_data.data.mac_hdr.countdown := (15 - i);
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(f_rnd_octstring(10))) };
-
-		/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-		f_tx_rlcmac_ul_block(ul_data, 40*10); /* 40 dB */
-
-		/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
-		f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
-
-		last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
-	}
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
+	last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
 
 	if (last_ch_coding != CH_CODING_CS3) {
 		setverdict(fail, "Channel Coding does not match our expectations (CS-3): ", last_ch_coding);
+		f_shutdown(__BFILE__, __LINE__);
 	}
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
@@ -763,18 +736,15 @@
 /* Verify PCU drops TBF after some time of inactivity. */
 testcase TC_t3169() runs on RAW_PCU_Test_CT {
 	var PCUIF_info_ind info_ind;
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
-	var octetstring data;
-	var boolean ok;
 	var uint32_t unused_fn;
-	var OCT4 tlli := '00000001'O;
-	var uint14_t bsn := 0;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	info_ind := valueof(ts_PCUIF_INFO_default);
 	/* Set timer to 1 sec (default 5) to speedup test: */
@@ -785,31 +755,22 @@
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine */
-	f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 1, tlli);
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(10), cv := 1, with_tlli := true)
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
-	/* UL block should be received in SGSN */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id));
+	/* UL block should NOT be received in SGSN, since we didn't get CV=0 */
 
 	/* Wait until T3169 fires (plus 1 extra sec to make sure) */
 	f_sleep(int2float(info_ind.t3169) + 1.0);
 
 	/* Send an UL block once again, the TBF should be gone by now so no ACK */
-	bsn := 0;
-	f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 1);
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(10), cv := 0)
 	f_rx_rlcmac_dl_block_exp_dummy(dl_block);
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
@@ -819,117 +780,99 @@
  * release of prev DL TBF due to MS staying in PDCH for a while (T3192, in PCU
  * T3193) after DL TBF release */
 testcase TC_t3193() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
 	var octetstring data := f_rnd_octstring(10);
 	var boolean ok;
 	var uint32_t sched_fn;
 	var uint32_t dl_fn;
-	var OCT4 tlli := '00000001'O;
+	var GprsMS ms;
 	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_establish_dl_tbf_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
-	/* we are done with the DL-TBF here so far, let's clean up our local state: */
-	ack_nack_desc := valueof(t_AckNackDescription_init)
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	/* Now that final DL block is ACKED and TBF is released, T3193 in PCU
-	   (T3192 in MS) was started and until it fires the MS will be abailable
+	   (T3192 in MS) was started and until it fires the MS will be available
 	   on PDCH in case new data arrives from SGSN. Let's verify it: */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_rx_rlcmac_dl_block_exp_pkt_ass(dl_block, sched_fn);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_rx_imm_ass_rlcmac(ms, sched_fn, tr_RLCMAC_DL_PACKET_ASS);
+
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* Now that we confirmed the new assignment in the dl-tbf, lets receive the data and ack it */
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0);
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
 
 /* Verify PCU handles correctly Countdown Procedure based on BS_CV_MAX */
 testcase TC_countdown_procedure() runs on RAW_PCU_Test_CT  {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
 	var uint32_t sched_fn;
-	var OCT4 tlli := '00000001'O;
-	var uint14_t bsn := 1;
-	var PDU_BSSGP bssgp_pdu;
 	var octetstring total_payload;
-	var integer padding_len;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine. */
-	   total_payload := f_rnd_octstring(16); /* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA_TLLI(
-		tfi := ul_tbf_ass.dynamic.tfi_assignment,
-		cv := 15, /* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
-		bsn := 0,
-		blocks := { valueof(t_RLCMAC_LLCBLOCK(total_payload)) },
-		tlli := tlli);
-
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	total_payload := f_rnd_octstring(16); /* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
+	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
+	f_ms_tx_ul_data_block(ms, total_payload, cv := 15, with_tlli := true)
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* Send enough blocks to test whole procedure: Until Nth block
 	   (N=BS_CV_MAX), CV=15 is sent, and then the decreasing countdown value is sent.
 	 */
-	total_payload := total_payload & f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 20);
+	total_payload := total_payload & f_ms_tx_ul_data_block_multi(ms, 20);
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* receive one message on BSSGP with all aggregated data in payload: */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id, total_payload));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id, total_payload));
 }
 
 /* Test scenario where MS wants to send some data on PDCH against SGSN and it is
@@ -937,63 +880,50 @@
  */
 private function f_TC_mo_ping_pong_1phase_access(template (present) CodingScheme exp_cs_mcs := ?) runs on RAW_PCU_Test_CT {
 	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
 	var octetstring data := f_rnd_octstring(10);
-	var boolean ok;
 	var uint32_t sched_fn;
 	var uint32_t dl_fn;
-	var OCT4 tlli := '00000001'O;
-	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
-	var uint14_t bsn := 0;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine */
-	f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 1, tlli);
+	f_ms_tx_ul_data_block_multi(ms, 1, with_tlli := true);
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* UL block should be received in SGSN */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id));
 
 	/* Now SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_establish_dl_tbf_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0, exp_cs_mcs);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			     f_dl_block_ack_fn(dl_block, dl_fn));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -1013,20 +943,13 @@
 						 template (present) CodingScheme exp_ul_cs_mcs := ?,
 						 template (present) CodingScheme exp_dl_cs_mcs := ?)
 runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
 	var octetstring data := f_rnd_octstring(10);
-	var boolean ok;
 	var uint32_t sched_fn;
 	var uint32_t dl_fn;
 	var uint32_t unused_fn;
-	var OCT4 tlli := '00000001'O;
-	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
-	var CodingScheme cs_mcs;
-	var uint14_t bsn := 0;
+	var GprsMS ms;
+
 	/* 0111 0xxx: Single block packet access; one block period on a PDCH is needed for two phase packet access or other RR signalling purpose. */
 	var uint16_t ra := oct2int('70'O);
 	if (g_force_two_phase_access) {
@@ -1038,55 +961,52 @@
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass, ra := ra);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_use_ra(ms, ra, ra_is_11bit := 0);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass, tr_PacketUlSglAssign);
+	if (not match(ms.ul_tbf.ass, tr_PacketUlSglAssign)) {
+		setverdict(fail, "Wrong Packet Uplink Assignment received: ", ms.ul_tbf.ass, " vs exp: ", tr_PacketUlSglAssign);
+		f_shutdown(__BFILE__, __LINE__);
+	}
 
 	/* Send PACKET RESOURCE REQUEST to upgrade to EGPRS
 	 * (see 3GPP TS 04.60 "7.1.3.1 Initiation of the Packet resource request procedure")
 	 */
-	f_tx_rlcmac_ul_block(ts_RLC_UL_CTRL_ACK(valueof(ts_RlcMacUlCtrl_PKT_RES_REQ(tlli, ms_racap))), 0);
-	f_rx_rlcmac_dl_block_exp_pkt_ul_ass(dl_block, sched_fn);
-	if (dl_block.ctrl.payload.u.ul_assignment.identity.tlli.tlli != tlli) {
-		setverdict(fail, "Wrong TLLI ", dl_block.ctrl.payload.u.ul_assignment.identity.tlli, " received vs exp ", tlli);
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	cs_mcs := f_rlcmac_dl_block_get_assigned_ul_cs_mcs(dl_block);
-	if (not match(cs_mcs, exp_ul_cs_mcs)) {
-		setverdict(fail, "Wrong CS_MCS ", cs_mcs, " received vs exp ", exp_ul_cs_mcs);
+	f_ms_tx_ul_block(ms, ts_RLC_UL_CTRL_ACK(valueof(ts_RlcMacUlCtrl_PKT_RES_REQ(ms.tlli, ms_racap))), 0);
+	f_ms_rx_imm_ass_rlcmac(ms, sched_fn, tr_RLCMAC_UL_PACKET_ASS);
+	if (not match(ms.ul_tbf.tx_cs_mcs, exp_ul_cs_mcs)) {
+		setverdict(fail, "Wrong CS_MCS ", ms.ul_tbf.tx_cs_mcs, " received vs exp ", exp_ul_cs_mcs);
 		f_shutdown(__BFILE__, __LINE__);
 	}
 
 	/* Send one UL block (without TLLI since we are in Second-Phase Access)
 	   and make sure it is ACKED fine */
-	f_tx_rlcmac_ul_n_blocks(f_rlcmac_dl_block_get_tfi(dl_block), bsn, 1);  /* TODO: send using cs_mcs */
+	f_ms_tx_ul_data_block_multi(ms, 1, with_tlli := true);  /* TODO: send using cs_mcs */
 
-	//f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* UL block should be received in SGSN */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id));
 
 	/* Now SGSN sends some DL data, PCU will page on PACCH */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_rx_rlcmac_dl_block_exp_pkt_dl_ass(dl_block, sched_fn);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_rx_imm_ass_rlcmac(ms, sched_fn, tr_RLCMAC_DL_PACKET_ASS);
 	/* DL Ass sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* PCU acks the UL data after having received CV=0) */
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
@@ -1095,9 +1015,9 @@
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0, exp_dl_cs_mcs);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.ul_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -1152,64 +1072,50 @@
  * answered by the MS on PDCH, so TBFs for downlink and later for uplink are created.
  */
 private function f_TC_mt_ping_pong(template (omit) MSRadioAccessCapabilityV_BSSGP ms_racap := omit, template (present) CodingScheme exp_cs_mcs := ?) runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
 	var octetstring data := f_rnd_octstring(10);
-	var boolean ok;
 	var uint32_t sched_fn;
 	var uint32_t dl_fn;
-	var OCT4 tlli := '00000001'O;
-	var uint14_t bsn := 0;
-	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data, ms_racap));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data, ms_racap));
+	f_ms_establish_dl_tbf_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0, exp_cs_mcs);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	/* Now MS wants to answer the DL data, Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine */
-	f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 1, tlli);
+	f_ms_tx_ul_data_block_multi(ms, 1, with_tlli := true);
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* UL block should be received in SGSN */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -1237,123 +1143,102 @@
  * be transferred).
  */
 testcase TC_ul_intermediate_retrans() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
 	var template (value) RlcmacUlBlock ul_data;
-	var boolean ok;
 	var uint32_t sched_fn;
-	var OCT4 tlli := '00000001'O;
-	var uint14_t bsn := 5;
-	var PDU_BSSGP bssgp_pdu;
 	var octetstring total_payload;
 	var octetstring payload;
 	var octetstring lost_payload;
-	var integer padding_len;
 	var uint5_t tfi;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
-	tfi := ul_tbf_ass.dynamic.tfi_assignment;
+	f_ms_establish_ul_tbf(ms);
+	tfi := ms.ul_tbf.tfi;
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine. */
 	payload := f_rnd_octstring(16); /* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
-	ul_data := t_RLCMAC_UL_DATA_TLLI(
-		tfi := tfi,
-		cv := 15, /* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
-		bsn := 0,
-		blocks := { valueof(t_RLCMAC_LLCBLOCK(payload)) },
-		tlli := tlli);
+	f_ms_tx_ul_data_block(ms, payload, cv := 15, with_tlli := true);
 
-	f_tx_rlcmac_ul_block(ul_data, 0);
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 	total_payload := payload;
 
 	/* Send 2 packets, skip 1 (inc bsn) and send another one */
 	payload := f_rnd_octstring(20); /* 20 bytes fills the CS-1 llc block */
-	ul_data := t_RLCMAC_UL_DATA(tfi := tfi, cv := 15, bsn := 1, blocks := {t_RLCMAC_LLCBLOCK(payload)});
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	f_ms_tx_ul_data_block(ms, payload, cv := 15);
 	total_payload := total_payload & payload;
 
 	payload := f_rnd_octstring(20); /* 20 bytes fills the CS-1 llc block */
-	ul_data := t_RLCMAC_UL_DATA(tfi := tfi, cv := 15, bsn := 2, blocks := {t_RLCMAC_LLCBLOCK(payload)});
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	f_ms_tx_ul_data_block(ms, payload, cv := 15);
 	total_payload := total_payload & payload;
 
-	lost_payload := f_rnd_octstring(20); /* LOST PAYLOAD bsn=3, will be retransmitted, next bsn is increased +2 */
+	lost_payload := f_rnd_octstring(20);
+	ms.ul_tbf.bsn := ms.ul_tbf.bsn + 1;  /* LOST PAYLOAD bsn=3, will be retransmitted, next bsn is increased +2 */
 	total_payload := total_payload & lost_payload;
 
 	payload := f_rnd_octstring(20); /* 20 bytes fills the CS-1 llc block */
-	ul_data := t_RLCMAC_UL_DATA(tfi := tfi, cv := 15, bsn := 4, blocks := {t_RLCMAC_LLCBLOCK(payload)});
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	f_ms_tx_ul_data_block(ms, payload, cv := 15);
 	total_payload := total_payload & payload;
 
 	/* Send enough blocks to finish the transmission (since we were sending BSN=15, send BS_CV_MAX packets) */
-	total_payload := total_payload & f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, g_bs_cv_max);
+	total_payload := total_payload & f_ms_tx_ul_data_block_multi(ms, g_bs_cv_max);
 
 	/* On CV=0, we'll receive a UL ACK asking about missing block */
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* TODO: check ack ack bitmap (URBB) */
 	ul_data := t_RLCMAC_UL_DATA(tfi := tfi, cv := 15, bsn := 3, blocks := {t_RLCMAC_LLCBLOCK(lost_payload)});
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	f_ms_tx_ul_block(ms, ul_data);
 
 	/* Now final ack is recieved */
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* receive one message on BSSGP with all aggregated data in payload: */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id, total_payload));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id, total_payload));
 }
 
 /* Verify that if PCU doesn't get an ACK for first DL block after IMM ASS, it
  * will retry by retransmitting both the IMM ASS + DL block after poll (ack)
  * timeout occurs (specified by sent RRBP on DL block). */
 testcase TC_imm_ass_dl_block_retrans() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
 	var octetstring data := f_rnd_octstring(10);
-	var boolean ok;
 	var uint32_t dl_fn;
-	var OCT4 tlli := '00000001'O;
-	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_establish_dl_tbf_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
@@ -1362,19 +1247,16 @@
 	/* Now we don't ack the dl block (emulate MS failed receiveing IMM ASS
 	 * or GPRS DL, or DL ACK was lost for some reason). As a result, PCU
 	 * should retrigger IMM ASS + GPRS DL procedure after poll timeout. */
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	f_ms_establish_dl_tbf_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -1389,38 +1271,32 @@
 	var RlcmacDlBlock dl_block;
 	var uint32_t ack_fn;
 	var uint32_t fn;
+	var GprsMS ms;
 	timer T := 5.0;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will page on CCCH (PCH) */
 	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment with DL TFI */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
-	if (not ispresent(dl_tbf_ass.group1)) {
-		setverdict(fail, "Immediate Assignment contains no DL TFI");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Get DL TFI from received Downlink TBF assignment */
-	var uint5_t tfi := dl_tbf_ass.group1.tfi_assignment;
+	f_ms_establish_dl_tbf_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS */
 	f_sleep(X2002);
 
 	/* Expect the first (GPRS DL) block with bsn=0 and rrbp_valid=1 */
 	f_rx_rlcmac_dl_block_exp_data(dl_block, fn, data, 0);
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block);
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block);
 
 	/* TDMA frame number on which we are supposed to send the ACK */
 	ack_fn := f_dl_block_ack_fn(dl_block, fn);
@@ -1434,24 +1310,24 @@
 
 		/* Make sure this block has the same TFI as was assigned
 		 * FIXME: this is only valid for GPRS, not EGPRS. */
-		if (dl_block.data.mac_hdr.hdr_ext.tfi != tfi) {
+		if (dl_block.data.mac_hdr.hdr_ext.tfi != ms.dl_tbf.tfi) {
 			setverdict(fail, "Rx DL data block with unexpected TFI: ",
 				   dl_block.data.mac_hdr.hdr_ext.tfi);
 			f_shutdown(__BFILE__, __LINE__);
 		}
 
 		/* Keep Ack/Nack description updated */
-		f_acknackdesc_ack_block(ack_nack_desc, dl_block);
+		f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block);
 
 		/* Break if this is the end of RRBP */
 		if (fn == ack_fn) {
-			ack_nack_desc.final_ack := '1'B;
+			ms.dl_tbf.acknack_desc.final_ack := '1'B;
 			break;
 		}
 	}
 
 	/* This is the end of RRBP, send Packet Downlink Ack/Nack */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(tfi, ack_nack_desc), fn := fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc), fn := fn);
 
 	/* Make sure that the next block (after the Ack) is dummy */
 	f_rx_rlcmac_dl_block_exp_dummy(dl_block);
@@ -1491,34 +1367,27 @@
  * 3. Expect a Paging Frame
  */
 testcase TC_paging_cs_from_bts() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
-	var OCT4 tlli := '00000001'O;
 	var MobileIdentityLV mi;
 	var octetstring mi_enc_lv;
 	var hexstring imsi := f_gen_imsi(42);
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* build mobile Identity */
 	mi := valueof(ts_MI_IMSI_LV(imsi));
@@ -1540,33 +1409,26 @@
  */
 private function f_tc_paging_cs_from_sgsn(Nsvci bvci, boolean use_ptmsi := false)
 runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
-	var OCT4 tlli := '00000001'O;
 	var hexstring imsi := f_gen_imsi(42);
 	var GsmTmsi tmsi;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send paging request with or without TMSI */
 	if (use_ptmsi) {
@@ -1605,19 +1467,22 @@
  */
 private function f_tc_paging_ps_from_sgsn(Nsvci bvci, boolean use_ptmsi := false)
 runs on RAW_PCU_Test_CT {
-	var OCT4 tlli := '00000001'O;
 	var integer imsi_suff_tx := 423;
 	var hexstring imsi := f_gen_imsi(imsi_suff_tx);
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Send BSSGP PAGING-PS (with or without TMSI), wait for RR Paging Request Type 1.
 	 * Make sure that both paging group (IMSI suffix) and Mobile Identity match. */
@@ -1646,23 +1511,20 @@
 }
 
 private function f_TC_egprs_pkt_chan_req(in EGPRSPktChRequest req,
-					 template GsmRrMessage t_imm_ass := ?,
-					 PCUIF_BurstType bt := BURST_TYPE_1)
+					 template GsmRrMessage t_imm_ass := ?)
 runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_msg;
 	var uint16_t ra11;
-	var boolean ok;
+	var GprsMS ms;
+
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	ra11 := enc_EGPRSPktChRequest2uint(req);
+	f_ms_use_ra(ms, ra11, ra_is_11bit := 1);
 	log("Sending EGPRS Packet Channel Request (", ra11, "): ", req);
 
-	ok := f_establish_tbf(rr_msg, ra := ra11, is_11bit := 1, burst_type := bt);
-	if (not ok) {
-		setverdict(fail, "Failed to establush an Uplink TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_establish_ul_tbf(ms);
 
-	if (not match(rr_msg, t_imm_ass)) {
+	if (not match(ms.ul_tbf.rr_imm_ass, t_imm_ass)) {
 		setverdict(fail, "Immediate Assignment does not match");
 		f_shutdown(__BFILE__, __LINE__);
 	}
@@ -1675,6 +1537,9 @@
 	var template IaRestOctets rest;
 	var template EgprsUlAss ul_ass;
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
@@ -1703,6 +1568,9 @@
 	var template IaRestOctets rest;
 	var template EgprsUlAss ul_ass;
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
@@ -1737,6 +1605,9 @@
 	var template IaRestOctets rest;
 	var template EgprsUlAss ul_ass;
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
diff --git a/pcu/PCU_selftest.ttcn b/pcu/PCU_selftest.ttcn
index 70138bf..91bab7f 100644
--- a/pcu/PCU_selftest.ttcn
+++ b/pcu/PCU_selftest.ttcn
@@ -255,6 +255,7 @@
 
 testcase TC_selftest_rlcmac_egprs() runs on RAW_PCU_Test_CT
 {
+	var GprsMS ms;
 	var octetstring data;
 	var CodingSchemeArray schemes := {
 		//MCS_0,
@@ -269,6 +270,10 @@
 		MCS_9
 		};
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
+
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
@@ -291,7 +296,7 @@
 		data := f_pad_oct(data, f_rlcmac_cs_mcs2block_len(schemes[i]), '00'O);
 
 		/* Send to PCU so that we get gsmtap traces to verify with wireshark */
-		f_pcuif_tx_data_ind(data, 0, 0);
+		f_ms_tx_data_ind(ms, data, 0);
 
 		log("Decoding ", schemes[i]);
 		ul_data := dec_RlcmacUlBlock(data);

-- 
To view, visit https://gerrit.osmocom.org/c/osmo-ttcn3-hacks/+/18370
To unsubscribe, or for help writing mail filters, visit https://gerrit.osmocom.org/settings

Gerrit-Project: osmo-ttcn3-hacks
Gerrit-Branch: master
Gerrit-Change-Id: Ib3fee37580f0ea0530a659dec83656799bf57288
Gerrit-Change-Number: 18370
Gerrit-PatchSet: 1
Gerrit-Owner: pespin <pespin at sysmocom.de>
Gerrit-MessageType: newchange
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.osmocom.org/pipermail/gerrit-log/attachments/20200519/1b677beb/attachment.htm>


More information about the gerrit-log mailing list