aboutsummaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/meas/meas_test.c22
-rw-r--r--tests/meas/meas_test.ok148
-rw-r--r--tests/meas/meas_testcases.h519
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,
+ },
+};
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-29 01:33:11 +0000