measurement: substitue missing measurements

At the moment the measurement calculation of osmo-bts works by
collecting the measurement reports the phy emits during a measurement
interval. Normally one would expect a well defind fixed number here, but
some phys will not emit a measurement report for lost blocks. Also
blocks and their reports may get lost because of cpu overload etc.

The computation that is executed at the end of the measurement interval
computes over all received measurement. This evenutally means that
missing measurements will not taken into account and the result will
look better than it is in reality.

To fix this, the interval must be of a defined size and in cases where
less measurements as expected were collected, the algorithm must assume
they have been received with a 100%BER and take that into account.
However, all RSSI and TA/TOA related computations should continue to
rely on actual measurement data.

- make sure the algorithm works over a fixed interval
- replace missing measurements with 100%BER
- fix and extend unit-tests

Change-Id: Idd30fc07603ad7d042c1fb416e247c3bf7d35c8b
Related: OS#2987

3 files changed, 633 insertions, 56 deletions

diff --git a/tests/meas/meas_test.c b/tests/meas/meas_test.c
index b90227a7..c397ddd1 100644
--- a/tests/meas/meas_test.c
+++ b/tests/meas/meas_test.c
@@ -24,6 +24,7 @@ struct fn_sample {
 #include "sysmobts_fr_samples.h"
 #include "meas_testcases.h"
 
+
 void test_fn_sample(struct fn_sample *s, unsigned int len, uint8_t pchan, uint8_t tsmap)
 {
 	int rc;
@@ -73,13 +74,16 @@ static void reset_lchan_meas(struct gsm_lchan *lchan)
 
 static void test_meas_compute(const struct meas_testcase *mtc)
 {
-	struct gsm_lchan *lchan = &trx->ts[1].lchan[0];
+	struct gsm_lchan *lchan;
 	unsigned int i;
 	unsigned int fn = 0;
 
-	printf("\nMeasurement Compute Test %s\n", mtc->name);
+	printf("\n\n");
+	printf("===========================================================\n");
+	printf("Measurement Compute Test: %s\n", mtc->name);
 
-	lchan->ts->pchan = GSM_PCHAN_TCH_F;
+	lchan = &trx->ts[mtc->ts].lchan[0];
+	lchan->ts->pchan = mtc->pchan;
 	reset_lchan_meas(lchan);
 
 	/* feed uplink measurements into the code */
@@ -94,6 +98,8 @@ static void test_meas_compute(const struct meas_testcase *mtc)
 		OSMO_ASSERT(!(lchan->meas.flags & LC_UL_M_F_RES_VALID));
 	} else {
 		OSMO_ASSERT(lchan->meas.flags & (LC_UL_M_F_RES_VALID|LC_UL_M_F_OSMO_EXT_VALID));
+		printf("number of measurements: %u\n",  mtc->ulm_count);
+		printf("parameter                | actual | expected\n");
 		printf("meas.ext.toa256_min      | %6d | %6d\n",
 			lchan->meas.ext.toa256_min, mtc->res.toa256_min);
 		printf("meas.ext.toa256_max      | %6d | %6d\n",
@@ -113,6 +119,7 @@ static void test_meas_compute(const struct meas_testcase *mtc)
 		    (lchan->meas.ext.toa256_std_dev != mtc->res.toa256_std_dev) ||
 		    (lchan->meas.ul_res.full.rx_lev != mtc->res.rx_lev_full)) {
 			fprintf(stderr, "%s: Unexpected measurement result!\n", mtc->name);
+			OSMO_ASSERT(false);
 		}
 	}
 
@@ -1121,6 +1128,15 @@ int main(int argc, char **argv)
 	test_meas_compute(&mtc3);
 	test_meas_compute(&mtc4);
 	test_meas_compute(&mtc5);
+	test_meas_compute(&mtc_tch_f_complete);
+	test_meas_compute(&mtc_tch_f_dtx_with_lost_subs);
+	test_meas_compute(&mtc_tch_f_dtx);
+	test_meas_compute(&mtc_tch_h_complete);
+	test_meas_compute(&mtc_tch_h_dtx_with_lost_subs);
+	test_meas_compute(&mtc_tch_h_dtx);
+	test_meas_compute(&mtc_overrun);
+	test_meas_compute(&mtc_sdcch4_complete);
+	test_meas_compute(&mtc_sdcch8_complete);
 
 	printf("\n");
 	printf("***************************************************\n");
diff --git a/tests/meas/meas_test.ok b/tests/meas/meas_test.ok
index 58e527af..86d8d871 100644
--- a/tests/meas/meas_test.ok
+++ b/tests/meas/meas_test.ok
@@ -540,33 +540,167 @@ Testing: ts[7]->lchan[1], fn=15079=>015079/11/25/34/23, fn%104=103, rc=1, delta=
 Testing: ts[7]->lchan[0], fn=15170=>015170/11/12/23/14, fn%104=90, rc=1, delta=91
 Testing: ts[7]->lchan[1], fn=15183=>015183/11/25/36/27, fn%104=103, rc=1, delta=13
 
-Measurement Compute Test TOA256 Min-Max negative/positive
+
+===========================================================
+Measurement Compute Test: TOA256 Min-Max negative/positive
+number of measurements: 3
+parameter                | actual | expected
 meas.ext.toa256_min      |   -256 |   -256
 meas.ext.toa256_max      |    256 |    256
 meas.ms_toa256           |      0 |      0
 meas.ext.toa256_std_dev  |    209 |    209
 meas.ul_res.full.rx_lev  |     20 |     20
-meas.ul_res.full.rx_qual |      0 |      0
+meas.ul_res.full.rx_qual |      7 |      0
 
-Measurement Compute Test TOA256 small jitter around 256
+
+===========================================================
+Measurement Compute Test: TOA256 small jitter around 256
+number of measurements: 25
+parameter                | actual | expected
 meas.ext.toa256_min      |    254 |    254
 meas.ext.toa256_max      |    258 |    258
 meas.ms_toa256           |    256 |    256
 meas.ext.toa256_std_dev  |      1 |      1
 meas.ul_res.full.rx_lev  |     20 |     20
-meas.ul_res.full.rx_qual |      0 |      0
+meas.ul_res.full.rx_qual |      0 |      7
 
-Measurement Compute Test RxLEv averaging
+
+===========================================================
+Measurement Compute Test: RxLEv averaging
+number of measurements: 5
+parameter                | actual | expected
 meas.ext.toa256_min      |      0 |      0
 meas.ext.toa256_max      |      0 |      0
 meas.ms_toa256           |      0 |      0
 meas.ext.toa256_std_dev  |      0 |      0
 meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      7 |      0
+
+
+===========================================================
+Measurement Compute Test: Empty measurements
+number of measurements: 0
+parameter                | actual | expected
+meas.ext.toa256_min      |      0 |      0
+meas.ext.toa256_max      |      0 |      0
+meas.ms_toa256           |      0 |      0
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     63 |     63
+meas.ul_res.full.rx_qual |      3 |      3
+
+
+===========================================================
+Measurement Compute Test: TOA256 26 blocks with max TOA256
+number of measurements: 26
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      0 |      0
+
+
+===========================================================
+Measurement Compute Test: Complete TCH/F measurement period (26 measurements, 3 sub-frames)
+number of measurements: 25
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      0 |      0
+
+
+===========================================================
+Measurement Compute Test: Incomplete TCH/F measurement period (16 measurements, 1 sub-frame)
+number of measurements: 16
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      7 |      7
+
+
+===========================================================
+Measurement Compute Test: Incomplete but normal TCH/F measurement period (16 measurements, 3 sub-frames)
+number of measurements: 16
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      7 |      7
+
+
+===========================================================
+Measurement Compute Test: Complete TCH/H measurement period (26 measurements, 5 sub-frames)
+number of measurements: 25
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      0 |      0
+
+
+===========================================================
+Measurement Compute Test: Incomplete TCH/H measurement period (14 measurements, 3 sub-frames)
+number of measurements: 14
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      7 |      7
+
+
+===========================================================
+Measurement Compute Test: Incomplete but normal TCH/F measurement period (16 measurements, 5 sub-frames)
+number of measurements: 16
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      7 |      7
+
+
+===========================================================
+Measurement Compute Test: TCH/F measurement period with too much measurement values (overrun)
+number of measurements: 59
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
 meas.ul_res.full.rx_qual |      0 |      0
 
-Measurement Compute Test Empty measurements
 
-Measurement Compute Test TOA256 26 blocks with max TOA256
+===========================================================
+Measurement Compute Test: Complete SDCCH4 measurement period (3 measurements)
+number of measurements: 3
+parameter                | actual | expected
+meas.ext.toa256_min      |  16384 |  16384
+meas.ext.toa256_max      |  16384 |  16384
+meas.ms_toa256           |  16384 |  16384
+meas.ext.toa256_std_dev  |      0 |      0
+meas.ul_res.full.rx_lev  |     20 |     20
+meas.ul_res.full.rx_qual |      0 |      0
+
+
+===========================================================
+Measurement Compute Test: Complete SDCCH8 measurement period (3 measurements)
+number of measurements: 3
+parameter                | actual | expected
 meas.ext.toa256_min      |  16384 |  16384
 meas.ext.toa256_max      |  16384 |  16384
 meas.ms_toa256           |  16384 |  16384
diff --git a/tests/meas/meas_testcases.h b/tests/meas/meas_testcases.h
index ff74a207..fefa34f7 100644
--- a/tests/meas/meas_testcases.h
+++ b/tests/meas/meas_testcases.h
@@ -1,5 +1,5 @@
-#define ULM(ber, ta, neg_rssi) \
-	{ .ber10k = (ber), .ta_offs_256bits = (ta), .c_i = 1.0, .is_sub = 0, .inv_rssi = (neg_rssi) }
+#define ULM(ber, ta, sub, neg_rssi) \
+	{ .ber10k = (ber), .ta_offs_256bits = (ta), .c_i = 1.0, .is_sub = sub, .inv_rssi = (neg_rssi) }
 
 struct meas_testcase {
 	const char *name;
@@ -7,6 +7,8 @@ struct meas_testcase {
 	const struct bts_ul_meas *ulm;
 	unsigned int ulm_count;
 	uint32_t final_fn;
+	uint8_t ts;
+	enum gsm_phys_chan_config pchan;
 	/* results */
 	struct {
 		int success;
@@ -20,15 +22,21 @@ struct meas_testcase {
 };
 
 static struct bts_ul_meas ulm1[] = {
-	ULM(0, 0, 90),
-	ULM(0, 256, 90),
-	ULM(0, -256, 90),
+	/* Note: The assumptions about the frame number and the subset
+	 * allegiance is random since for the calculation only the amount
+	 * is of relevance. This is true for all following testcases */
+	ULM(0, 0, 0, 90),
+	ULM(0, 256, 0, 90),
+	ULM(0, -256, 0, 90),
 };
+
 static const struct meas_testcase mtc1 = {
 	.name = "TOA256 Min-Max negative/positive",
 	.ulm = ulm1,
 	.ulm_count = ARRAY_SIZE(ulm1),
 	.final_fn = 25,
+	.ts = 1,
+	.pchan = GSM_PCHAN_TCH_F,
 	.res = {
 		.success = 1,
 		.rx_lev_full = 110-90,
@@ -41,22 +49,44 @@ static const struct meas_testcase mtc1 = {
 };
 
 static struct bts_ul_meas ulm2[] = {
-	ULM(0, 256, 90),
-	ULM(0, 258, 90),
-	ULM(0, 254, 90),
-	ULM(0, 258, 90),
-	ULM(0, 254, 90),
-	ULM(0, 256, 90),
+	ULM(0, 256, 0, 90),
+	ULM(0, 258, 0, 90),
+	ULM(0, 254, 0, 90),
+	ULM(0, 258, 0, 90),
+	ULM(0, 254, 1, 90),
+	ULM(0, 256, 0, 90),
+	ULM(0, 256, 0, 90),
+	ULM(0, 258, 0, 90),
+	ULM(0, 254, 1, 90),
+	ULM(0, 258, 0, 90),
+	ULM(0, 254, 0, 90),
+	ULM(0, 256, 1, 90),
+	ULM(0, 256, 0, 90),
+	ULM(0, 258, 0, 90),
+	ULM(0, 254, 0, 90),
+	ULM(0, 258, 0, 90),
+	ULM(0, 254, 0, 90),
+	ULM(0, 256, 0, 90),
+	ULM(0, 256, 0, 90),
+	ULM(0, 258, 0, 90),
+	ULM(0, 254, 0, 90),
+	ULM(0, 258, 0, 90),
+	ULM(0, 254, 0, 90),
+	ULM(0, 256, 0, 90),
+	ULM(0, 256, 0, 90),
 };
+
 static const struct meas_testcase mtc2 = {
 	.name = "TOA256 small jitter around 256",
 	.ulm = ulm2,
 	.ulm_count = ARRAY_SIZE(ulm2),
 	.final_fn = 25,
+	.ts = 1,
+	.pchan = GSM_PCHAN_TCH_F,
 	.res = {
 		.success = 1,
 		.rx_lev_full = 110-90,
-		.rx_qual_full = 0,
+		.rx_qual_full = 7,
 		.toa256_mean = 256,
 		.toa256_max = 258,
 		.toa256_min = 254,
@@ -65,17 +95,20 @@ static const struct meas_testcase mtc2 = {
 };
 
 static struct bts_ul_meas ulm3[] = {
-	ULM(0, 0, 90),
-	ULM(0, 0, 80),
-	ULM(0, 0, 80),
-	ULM(0, 0, 100),
-	ULM(0, 0, 100),
+	ULM(0, 0, 0, 90),
+	ULM(0, 0, 0, 80),
+	ULM(0, 0, 0, 80),
+	ULM(0, 0, 0, 100),
+	ULM(0, 0, 0, 100),
 };
+
 static const struct meas_testcase mtc3 = {
 	.name = "RxLEv averaging",
 	.ulm = ulm3,
 	.ulm_count = ARRAY_SIZE(ulm3),
 	.final_fn = 25,
+	.ts = 1,
+	.pchan = GSM_PCHAN_TCH_F,
 	.res = {
 		.success = 1,
 		.rx_lev_full = 110-90,
@@ -88,15 +121,18 @@ static const struct meas_testcase mtc3 = {
 };
 
 static struct bts_ul_meas ulm4[] = {};
+
 static const struct meas_testcase mtc4 = {
 	.name = "Empty measurements",
 	.ulm = ulm4,
 	.ulm_count = ARRAY_SIZE(ulm4),
 	.final_fn = 25,
+	.ts = 1,
+	.pchan = GSM_PCHAN_TCH_F,
 	.res = {
-		.success = 0,
-		.rx_lev_full = 0,
-		.rx_qual_full = 0,
+		.success = 1,
+		.rx_lev_full = 63,
+		.rx_qual_full = 3,
 		.toa256_mean = 0,
 		.toa256_max = 0,
 		.toa256_min = 0,
@@ -107,38 +143,41 @@ static const struct meas_testcase mtc4 = {
 static struct bts_ul_meas ulm5[] = {
 	/* one 104 multiframe can at max contain 26 blocks (TCH/F),
 	 * each of which can at maximum be 64 bits in advance (TA range) */
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
-	ULM(0, 64*256, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
 };
+
 static const struct meas_testcase mtc5 = {
 	.name = "TOA256 26 blocks with max TOA256",
 	.ulm = ulm5,
 	.ulm_count = ARRAY_SIZE(ulm5),
 	.final_fn = 25,
+	.ts = 1,
+	.pchan = GSM_PCHAN_TCH_F,
 	.res = {
 		.success = 1,
 		.rx_lev_full = 110-90,
@@ -149,3 +188,391 @@ static const struct meas_testcase mtc5 = {
 		.toa256_std_dev = 0,
 	},
 };
+
+/* This testcase models a good case as we can see it when all TCH
+ * and SACCH blocks are received */
+static struct bts_ul_meas ulm_tch_f_complete[] = {
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+};
+
+static const struct meas_testcase mtc_tch_f_complete = {
+	.name = "Complete TCH/F measurement period (26 measurements, 3 sub-frames)",
+	.ulm = ulm_tch_f_complete,
+	.ulm_count = ARRAY_SIZE(ulm_tch_f_complete),
+	.final_fn = 38,
+	.ts = 2,
+	.pchan = GSM_PCHAN_TCH_F,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 20,
+		.rx_qual_full = 0,
+		.toa256_mean = 64*256,
+		.toa256_max = 64*256,
+		.toa256_min = 64*256,
+		.toa256_std_dev = 0,
+	},
+};
+
+/* This testcase models an error case where two of 3 expected sub measurements
+ * are lost. The calculation logic must detect this and replace those
+ * measurements. Note that this example also lacks some blocks due to DTX,
+ * which is normal. */
+static struct bts_ul_meas ulm_tch_f_dtx_with_lost_subs[] = {
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+};
+
+static const struct meas_testcase mtc_tch_f_dtx_with_lost_subs = {
+	/* This testcase models a good case as we can see it when all TCH
+	 * and SACCH blocks are received */
+	.name = "Incomplete TCH/F measurement period (16 measurements, 1 sub-frame)",
+	.ulm = ulm_tch_f_dtx_with_lost_subs,
+	.ulm_count = ARRAY_SIZE(ulm_tch_f_dtx_with_lost_subs),
+	.final_fn = 38,
+	.ts = 2,
+	.pchan = GSM_PCHAN_TCH_F,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 20,
+		.rx_qual_full = 7,
+		.toa256_mean = 16384,
+		.toa256_max = 16384,
+		.toa256_min = 16384,
+		.toa256_std_dev = 0,
+	},
+};
+
+/* This testcase models a good-case with DTX. Some measurements are missing
+ * because no block was transmitted, all sub measurements are there. */
+static struct bts_ul_meas ulm_tch_f_dtx[] = {
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+};
+
+static const struct meas_testcase mtc_tch_f_dtx = {
+	.name = "Incomplete but normal TCH/F measurement period (16 measurements, 3 sub-frames)",
+	.ulm = ulm_tch_f_dtx,
+	.ulm_count = ARRAY_SIZE(ulm_tch_f_dtx),
+	.final_fn = 38,
+	.ts = 2,
+	.pchan = GSM_PCHAN_TCH_F,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 20,
+		.rx_qual_full = 7,
+		.toa256_mean = 16384,
+		.toa256_max = 16384,
+		.toa256_min = 16384,
+		.toa256_std_dev = 0,
+	},
+};
+
+/* This testcase models a good case as we can see it when all TCH
+ * and SACCH blocks are received */
+static struct bts_ul_meas ulm_tch_h_complete[] = {
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+};
+
+static const struct meas_testcase mtc_tch_h_complete = {
+	.name = "Complete TCH/H measurement period (26 measurements, 5 sub-frames)",
+	.ulm = ulm_tch_h_complete,
+	.ulm_count = ARRAY_SIZE(ulm_tch_h_complete),
+	.final_fn = 38,
+	.ts = 2,
+	.pchan = GSM_PCHAN_TCH_H,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 110 - 90,
+		.rx_qual_full = 0,
+		.toa256_mean = 64*256,
+		.toa256_max = 64*256,
+		.toa256_min = 64*256,
+		.toa256_std_dev = 0,
+	},
+};
+
+static struct bts_ul_meas ulm_tch_h_dtx_with_lost_subs[] = {
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+};
+
+static const struct meas_testcase mtc_tch_h_dtx_with_lost_subs = {
+	.name = "Incomplete TCH/H measurement period (14 measurements, 3 sub-frames)",
+	.ulm = ulm_tch_h_dtx_with_lost_subs,
+	.ulm_count = ARRAY_SIZE(ulm_tch_h_dtx_with_lost_subs),
+	.final_fn = 38,
+	.ts = 2,
+	.pchan = GSM_PCHAN_TCH_H,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 20,
+		.rx_qual_full = 7,
+		.toa256_mean = 16384,
+		.toa256_max = 16384,
+		.toa256_min = 16384,
+		.toa256_std_dev = 0,
+	},
+};
+
+/* This testcase models a good-case with DTX. Some measurements are missing
+ * because no block was transmitted, all sub measurements are there. */
+static struct bts_ul_meas ulm_tch_h_dtx[] = {
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+};
+
+static const struct meas_testcase mtc_tch_h_dtx = {
+	.name = "Incomplete but normal TCH/F measurement period (16 measurements, 5 sub-frames)",
+	.ulm = ulm_tch_h_dtx,
+	.ulm_count = ARRAY_SIZE(ulm_tch_h_dtx),
+	.final_fn = 38,
+	.ts = 2,
+	.pchan = GSM_PCHAN_TCH_H,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 20,
+		.rx_qual_full = 7,
+		.toa256_mean = 16384,
+		.toa256_max = 16384,
+		.toa256_min = 16384,
+		.toa256_std_dev = 0,
+	},
+};
+
+/* This testcase assumes that too many measurements were collected. This can
+ * happen when the measurement calculation for a previous cycle were not
+ * executed. In this case the older part of the excess data must be discarded.
+ * the calculation algorithm must make sure that the calculation only takes
+ * place on the last measurement interval */
+static struct bts_ul_meas ulm_overrun[] = {
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	/* All measurements above must be discarded */
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+	ULM(0, 64*256, 0, 90),
+};
+
+static const struct meas_testcase mtc_overrun = {
+	.name = "TCH/F measurement period with too much measurement values (overrun)",
+	.ulm = ulm_overrun,
+	.ulm_count = ARRAY_SIZE(ulm_overrun),
+	.final_fn = 25,
+	.ts = 1,
+	.pchan = GSM_PCHAN_TCH_F,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 110 - 90,
+		.rx_qual_full = 0,
+		.toa256_mean = 64*256,
+		.toa256_max = 64*256,
+		.toa256_min = 64*256,
+		.toa256_std_dev = 0,
+	},
+};
+
+/* Test SDCCH4 with all frames received */
+static struct bts_ul_meas ulm_sdcch4_complete[] = {
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 1, 90),
+};
+
+static const struct meas_testcase mtc_sdcch4_complete = {
+	.name = "Complete SDCCH4 measurement period (3 measurements)",
+	.ulm = ulm_sdcch4_complete,
+	.ulm_count = ARRAY_SIZE(ulm_sdcch4_complete),
+	.final_fn = 88,
+	.ts = 0,
+	.pchan = GSM_PCHAN_CCCH_SDCCH4,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 20,
+		.rx_qual_full = 0,
+		.toa256_mean = 16384,
+		.toa256_max = 16384,
+		.toa256_min = 16384,
+		.toa256_std_dev = 0,
+	},
+};
+
+/* Test SDCCH8 with all frames received */
+static struct bts_ul_meas ulm_sdcch8_complete[] = {
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 1, 90),
+	ULM(0, 64*256, 1, 90),
+};
+
+static const struct meas_testcase mtc_sdcch8_complete = {
+	.name = "Complete SDCCH8 measurement period (3 measurements)",
+	.ulm = ulm_sdcch8_complete,
+	.ulm_count = ARRAY_SIZE(ulm_sdcch8_complete),
+	.final_fn = 66,
+	.ts = 0,
+	.pchan = GSM_PCHAN_SDCCH8_SACCH8C,
+	.res = {
+		.success = 1,
+		.rx_lev_full = 20,
+		.rx_qual_full = 0,
+		.toa256_mean = 16384,
+		.toa256_max = 16384,
+		.toa256_min = 16384,
+		.toa256_std_dev = 0,
+	},
+};