diff --git a/tests/handover/handover_test.c b/tests/handover/handover_test.c
new file mode 100644
index 0000000..e8716f2
--- /dev/null
+++ b/tests/handover/handover_test.c
@@ -0,0 +1,1615 @@
+/*
+ * (C) 2013 by Andreas Eversberg <jolly@eversberg.eu>
+ * All Rights Reserved
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include <assert.h>
+
+#include <osmocom/core/application.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/talloc.h>
+
+#include <osmocom/bsc/abis_rsl.h>
+#include <osmocom/bsc/debug.h>
+#include <osmocom/bsc/bsc_subscriber.h>
+#include <osmocom/bsc/chan_alloc.h>
+#include <osmocom/bsc/handover_decision.h>
+#include <osmocom/bsc/system_information.h>
+#include <osmocom/bsc/handover_cfg.h>
+#include <osmocom/bsc/handover_decision_2.h>
+#include <osmocom/bsc/common_bsc.h>
+#include <osmocom/bsc/bss.h>
+#include <osmocom/bsc/bsc_api.h>
+#include <osmocom/bsc/osmo_bsc.h>
+
+struct gsm_network *bsc_gsmnet;
+
+/* measurement report */
+
+uint8_t meas_rep_ba = 0, meas_rep_valid = 1, meas_valid = 1, meas_multi_rep = 0;
+uint8_t meas_dl_rxlev = 0, meas_dl_rxqual = 0;
+uint8_t meas_ul_rxlev = 0, meas_ul_rxqual = 0;
+uint8_t meas_tx_power_ms = 0, meas_tx_power_bs = 0, meas_ta_ms = 0;
+uint8_t meas_dtx_ms = 0, meas_dtx_bs = 0, meas_nr = 0;
+uint8_t meas_num_nc = 0, meas_rxlev_nc[6], meas_bsic_nc[6], meas_bcch_f_nc[6];
+
+static void gen_meas_rep(struct gsm_lchan *lchan)
+{
+	struct msgb *msg = msgb_alloc_headroom(256, 64, "RSL");
+	struct abis_rsl_dchan_hdr *dh;
+	uint8_t chan_nr = gsm_lchan2chan_nr(lchan);
+	uint8_t ulm[3], l1i[2], *buf;
+	struct gsm48_hdr *gh;
+	struct gsm48_meas_res *mr;
+
+	dh = (struct abis_rsl_dchan_hdr *) msgb_put(msg, sizeof(*dh));
+	dh->c.msg_discr = ABIS_RSL_MDISC_DED_CHAN;
+	dh->c.msg_type = RSL_MT_MEAS_RES;
+	dh->ie_chan = RSL_IE_CHAN_NR;
+	dh->chan_nr = chan_nr;
+
+	msgb_tv_put(msg, RSL_IE_MEAS_RES_NR, meas_nr++);
+
+	ulm[0] = meas_ul_rxlev | (meas_dtx_bs << 7);
+	ulm[1] = meas_ul_rxlev;
+	ulm[2] = (meas_ul_rxqual << 3) | meas_ul_rxqual;
+	msgb_tlv_put(msg, RSL_IE_UPLINK_MEAS, sizeof(ulm), ulm);
+
+	msgb_tv_put(msg, RSL_IE_BS_POWER, meas_tx_power_bs);
+
+	l1i[0] = 0;
+	l1i[1] = meas_ta_ms;
+	msgb_tv_fixed_put(msg, RSL_IE_L1_INFO, sizeof(l1i), l1i);
+
+	buf = msgb_put(msg, 3);
+	buf[0] = RSL_IE_L3_INFO;
+	buf[1] = (sizeof(*gh) + sizeof(*mr)) >> 8;
+	buf[2] = (sizeof(*gh) + sizeof(*mr)) & 0xff;
+
+	gh = (struct gsm48_hdr *) msgb_put(msg, sizeof(*gh));
+	mr = (struct gsm48_meas_res *) msgb_put(msg, sizeof(*mr));
+
+	gh->proto_discr = GSM48_PDISC_RR;
+	gh->msg_type = GSM48_MT_RR_MEAS_REP;
+
+	/* measurement results */
+	mr->rxlev_full = meas_dl_rxlev;
+	mr->rxlev_sub = meas_dl_rxlev;
+	mr->rxqual_full = meas_dl_rxqual;
+	mr->rxqual_sub = meas_dl_rxqual;
+	mr->dtx_used = meas_dtx_ms;
+	mr->ba_used = meas_rep_ba;
+	mr->meas_valid = !meas_valid; /* 0 = valid */
+	if (meas_rep_valid) {
+		mr->no_nc_n_hi = meas_num_nc >> 2;
+		mr->no_nc_n_lo = meas_num_nc & 3;
+	} else {
+		/* no results for serving cells */
+		mr->no_nc_n_hi = 1;
+		mr->no_nc_n_lo = 3;
+	}
+	mr->rxlev_nc1 = meas_rxlev_nc[0];
+	mr->rxlev_nc2_hi = meas_rxlev_nc[1] >> 1;
+	mr->rxlev_nc2_lo = meas_rxlev_nc[1] & 1;
+	mr->rxlev_nc3_hi = meas_rxlev_nc[2] >> 2;
+	mr->rxlev_nc3_lo = meas_rxlev_nc[2] & 3;
+	mr->rxlev_nc4_hi = meas_rxlev_nc[3] >> 3;
+	mr->rxlev_nc4_lo = meas_rxlev_nc[3] & 7;
+	mr->rxlev_nc5_hi = meas_rxlev_nc[4] >> 4;
+	mr->rxlev_nc5_lo = meas_rxlev_nc[4] & 15;
+	mr->rxlev_nc6_hi = meas_rxlev_nc[5] >> 5;
+	mr->rxlev_nc6_lo = meas_rxlev_nc[5] & 31;
+	mr->bsic_nc1_hi = meas_bsic_nc[0] >> 3;
+	mr->bsic_nc1_lo = meas_bsic_nc[0] & 7;
+	mr->bsic_nc2_hi = meas_bsic_nc[1] >> 4;
+	mr->bsic_nc2_lo = meas_bsic_nc[1] & 15;
+	mr->bsic_nc3_hi = meas_bsic_nc[2] >> 5;
+	mr->bsic_nc3_lo = meas_bsic_nc[2] & 31;
+	mr->bsic_nc4 = meas_bsic_nc[3];
+	mr->bsic_nc5 = meas_bsic_nc[4];
+	mr->bsic_nc6 = meas_bsic_nc[5];
+	mr->bcch_f_nc1 = meas_bcch_f_nc[0];
+	mr->bcch_f_nc2 = meas_bcch_f_nc[1];
+	mr->bcch_f_nc3 = meas_bcch_f_nc[2];
+	mr->bcch_f_nc4 = meas_bcch_f_nc[3];
+	mr->bcch_f_nc5_hi = meas_bcch_f_nc[4] >> 1;
+	mr->bcch_f_nc5_lo = meas_bcch_f_nc[4] & 1;
+	mr->bcch_f_nc6_hi = meas_bcch_f_nc[5] >> 2;
+	mr->bcch_f_nc6_lo = meas_bcch_f_nc[5] & 3;
+
+	msg->dst = lchan->ts->trx->bts->c0->rsl_link;
+	msg->l2h = (unsigned char *)dh;
+	msg->l3h = (unsigned char *)gh;
+
+	abis_rsl_rcvmsg(msg);
+}
+
+static struct gsm_bts *create_bts(int arfcn)
+{
+	struct gsm_bts *bts;
+	struct e1inp_sign_link *rsl_link;
+	int i;
+
+	bts = gsm_bts_alloc_register(bsc_gsmnet, GSM_BTS_TYPE_OSMOBTS, 0x3f);
+	if (!bts) {
+		printf("No resource for bts1\n");
+		return NULL;
+	}
+
+	bts->location_area_code = 23;
+	bts->c0->arfcn = arfcn;
+
+	bts->codec.efr = 1;
+	bts->codec.hr = 1;
+	bts->codec.amr = 1;
+
+	rsl_link = talloc_zero(0, struct e1inp_sign_link);
+	rsl_link->trx = bts->c0;
+	bts->c0->rsl_link = rsl_link;
+
+	bts->c0->mo.nm_state.operational = NM_OPSTATE_ENABLED;
+	bts->c0->mo.nm_state.availability = NM_AVSTATE_OK;
+	bts->c0->bb_transc.mo.nm_state.operational = NM_OPSTATE_ENABLED;
+	bts->c0->bb_transc.mo.nm_state.availability = NM_AVSTATE_OK;
+
+	/* 4 full rate and 4 half rate channels */
+	for (i = 1; i <= 6; i++) {
+		bts->c0->ts[i].pchan =
+			(i < 5) ? GSM_PCHAN_TCH_F : GSM_PCHAN_TCH_H;
+		bts->c0->ts[i].mo.nm_state.operational = NM_OPSTATE_ENABLED;
+		bts->c0->ts[i].mo.nm_state.availability = NM_AVSTATE_OK;
+		bts->c0->ts[i].lchan[0].type = GSM_LCHAN_NONE;
+		bts->c0->ts[i].lchan[0].state = LCHAN_S_NONE;
+		bts->c0->ts[i].lchan[1].type = GSM_LCHAN_NONE;
+		bts->c0->ts[i].lchan[1].state = LCHAN_S_NONE;
+	}
+	return bts;
+}
+
+void create_conn(struct gsm_lchan *lchan)
+{
+	lchan->conn = bsc_subscr_con_allocate(lchan);
+}
+
+/* create lchan */
+struct gsm_lchan *create_lchan(struct gsm_bts *bts, int full_rate, char *codec)
+{
+	struct gsm_lchan *lchan;
+
+	lchan = lchan_alloc(bts,
+		(full_rate) ? GSM_LCHAN_TCH_F : GSM_LCHAN_TCH_H, 0);
+	if (!lchan) {
+		printf("No resource for lchan\n");
+		exit(EXIT_FAILURE);
+	}
+	lchan->state = LCHAN_S_ACTIVE;
+	create_conn(lchan);
+	if (!strcasecmp(codec, "FR") && full_rate)
+		lchan->tch_mode = GSM48_CMODE_SPEECH_V1;
+	else if (!strcasecmp(codec, "HR") && !full_rate)
+		lchan->tch_mode = GSM48_CMODE_SPEECH_V1;
+	else if (!strcasecmp(codec, "EFR") && full_rate)
+		lchan->tch_mode = GSM48_CMODE_SPEECH_EFR;
+	else if (!strcasecmp(codec, "AMR"))
+		lchan->tch_mode = GSM48_CMODE_SPEECH_AMR;
+	else {
+		printf("Given codec unknown\n");
+		exit(EXIT_FAILURE);
+	}
+
+	lchan->conn->codec_list = (struct gsm0808_speech_codec_list){
+		.codec = {
+			{ .fi=true, .type=GSM0808_SCT_FR1, },
+			{ .fi=true, .type=GSM0808_SCT_FR2, },
+			{ .fi=true, .type=GSM0808_SCT_FR3, },
+			{ .fi=true, .type=GSM0808_SCT_HR1, },
+			{ .fi=true, .type=GSM0808_SCT_HR3, },
+		},
+		.len = 5,
+	};
+	lchan->conn->codec_list_present = true;
+
+	return lchan;
+}
+
+/* parse channel request */
+
+static int got_chan_req = 0;
+static struct gsm_lchan *chan_req_lchan = NULL;
+
+static int parse_chan_act(struct gsm_lchan *lchan, uint8_t *data)
+{
+	chan_req_lchan = lchan;
+	return 0;
+}
+
+static int parse_chan_rel(struct gsm_lchan *lchan, uint8_t *data)
+{
+	chan_req_lchan = lchan;
+	return 0;
+}
+
+/* parse handover request */
+
+static int got_ho_req = 0;
+static struct gsm_lchan *ho_req_lchan = NULL;
+
+static int parse_ho_command(struct gsm_lchan *lchan, uint8_t *data, int len)
+{
+	struct gsm48_hdr *gh = (struct gsm48_hdr *) data;
+	struct gsm48_ho_cmd *ho = (struct gsm48_ho_cmd *) gh->data;
+	int arfcn;
+	struct gsm_bts *neigh;
+
+	switch (gh->msg_type) {
+	case GSM48_MT_RR_HANDO_CMD:
+		arfcn = (ho->cell_desc.arfcn_hi << 8) | ho->cell_desc.arfcn_lo;
+
+		/* look up trx. since every dummy bts uses different arfcn and
+		 * only one trx, it is simple */
+		llist_for_each_entry(neigh, &bsc_gsmnet->bts_list, list) {
+			if (neigh->c0->arfcn != arfcn)
+				continue;
+			ho_req_lchan = lchan;
+			return 0;
+		}
+		break;
+	case GSM48_MT_RR_ASS_CMD:
+		ho_req_lchan = lchan;
+		return 0;
+		break;
+	default:
+		fprintf(stderr, "Error, expecting HO or AS command\n");
+		return -EINVAL;
+	}
+
+	return -1;
+}
+
+/* send channel activation ack */
+static void send_chan_act_ack(struct gsm_lchan *lchan, int act)
+{
+	struct msgb *msg = msgb_alloc_headroom(256, 64, "RSL");
+	struct abis_rsl_dchan_hdr *dh;
+
+	dh = (struct abis_rsl_dchan_hdr *) msgb_put(msg, sizeof(*dh));
+	dh->c.msg_discr = ABIS_RSL_MDISC_DED_CHAN;
+	dh->c.msg_type = (act) ? RSL_MT_CHAN_ACTIV_ACK : RSL_MT_RF_CHAN_REL_ACK;
+	dh->ie_chan = RSL_IE_CHAN_NR;
+	dh->chan_nr = gsm_lchan2chan_nr(lchan);
+
+	msg->dst = lchan->ts->trx->bts->c0->rsl_link;
+	msg->l2h = (unsigned char *)dh;
+
+	abis_rsl_rcvmsg(msg);
+}
+
+/* send handover complete */
+static void send_ho_complete(struct gsm_lchan *lchan, bool success)
+{
+	struct msgb *msg = msgb_alloc_headroom(256, 64, "RSL");
+	struct abis_rsl_rll_hdr *rh;
+	uint8_t chan_nr = gsm_lchan2chan_nr(lchan);
+	uint8_t *buf;
+	struct gsm48_hdr *gh;
+	struct gsm48_ho_cpl *hc;
+
+	rh = (struct abis_rsl_rll_hdr *) msgb_put(msg, sizeof(*rh));
+	rh->c.msg_discr = ABIS_RSL_MDISC_RLL;
+	rh->c.msg_type = RSL_MT_DATA_IND;
+	rh->ie_chan = RSL_IE_CHAN_NR;
+	rh->chan_nr = chan_nr;
+	rh->ie_link_id = RSL_IE_LINK_IDENT;
+	rh->link_id = 0x00;
+
+	buf = msgb_put(msg, 3);
+	buf[0] = RSL_IE_L3_INFO;
+	buf[1] = (sizeof(*gh) + sizeof(*hc)) >> 8;
+	buf[2] = (sizeof(*gh) + sizeof(*hc)) & 0xff;
+
+	gh = (struct gsm48_hdr *) msgb_put(msg, sizeof(*gh));
+	hc = (struct gsm48_ho_cpl *) msgb_put(msg, sizeof(*hc));
+
+	gh->proto_discr = GSM48_PDISC_RR;
+	gh->msg_type =
+		success ? GSM48_MT_RR_HANDO_COMPL : GSM48_MT_RR_HANDO_FAIL;
+
+	msg->dst = lchan->ts->trx->bts->c0->rsl_link;
+	msg->l2h = (unsigned char *)rh;
+	msg->l3h = (unsigned char *)gh;
+
+	abis_rsl_rcvmsg(msg);
+}
+
+/* RSL messages from BSC */
+int abis_rsl_sendmsg(struct msgb *msg)
+{
+	struct abis_rsl_dchan_hdr *dh = (struct abis_rsl_dchan_hdr *) msg->data;
+	struct e1inp_sign_link *sign_link = msg->dst;
+	int rc;
+	struct gsm_lchan *lchan = rsl_lchan_lookup(sign_link->trx, dh->chan_nr, &rc);
+
+	if (rc) {
+		printf("rsl_lchan_lookup() failed\n");
+		exit(1);
+	}
+
+	switch (dh->c.msg_type) {
+	case RSL_MT_CHAN_ACTIV:
+		rc = parse_chan_act(lchan, dh->data);
+		if (rc == 0)
+			got_chan_req = 1;
+		break;
+	case RSL_MT_RF_CHAN_REL:
+		rc = parse_chan_rel(lchan, dh->data);
+		if (rc == 0)
+			send_chan_act_ack(chan_req_lchan, 0);
+		break;
+	case RSL_MT_DATA_REQ:
+		rc = parse_ho_command(lchan, msg->l3h, msgb_l3len(msg));
+		if (rc == 0)
+			got_ho_req = 1;
+		break;
+	case RSL_MT_IPAC_CRCX:
+		break;
+	default:
+		printf("unknown rsl message=0x%x\n", dh->c.msg_type);
+	}
+	return 0;
+}
+
+/* test cases */
+
+static char *test_case_0[] = {
+	"2",
+
+	"Stay in better cell\n\n"
+	"There are many neighbor cells, but only the current cell is the best\n"
+	"cell, so no handover is performed\n",
+
+	"create-bts", "7",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "30","0",
+		"6","0","20","1","21","2","18","3","20","4","23","5","19",
+	"expect-no-chan",
+	NULL
+};
+
+static char *test_case_1[] = {
+	"2",
+
+	"Handover to best better cell\n\n"
+	"The best neighbor cell is selected\n",
+
+	"create-bts", "7",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "10","0",
+		"6","0","20","1","21","2","18","3","20","4","23","5","19",
+	"expect-chan", "5", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_2[] = {
+	"2",
+
+	"Handover and Assignment must be enabled\n\n"
+	"This test will start with disabled assignment and handover.  A\n"
+	"better neighbor cell (assignment enabled) will not be selected and \n"
+	"also no assignment from TCH/H to TCH/F to improve quality. There\n"
+	"will be no handover nor assignment. After enabling assignment on the\n"
+	"current cell, the MS will assign to TCH/F. After enabling handover\n"
+	"in the current cell, but disabling in the neighbor cell, handover\n"
+	"will not be performed, until it is enabled in the neighbor cell too.\n",
+
+	"create-bts", "2",
+	"afs-rxlev-improve", "0", "5",
+	"create-ms", "0", "TCH/H", "AMR",
+	"as-enable", "0", "0",
+	"ho-enable", "0", "0",
+	"meas-rep", "0", "0","0", "1","0","30",
+	"expect-no-chan",
+	"as-enable", "0", "1",
+	"meas-rep", "0", "0","0", "1","0","30",
+	"expect-chan", "0", "1",
+	"ack-chan",
+	"expect-ho", "0", "5",
+	"ho-complete",
+	"ho-enable", "0", "1",
+	"ho-enable", "1", "0",
+	"meas-rep", "0", "0","0", "1","0","30",
+	"expect-no-chan",
+	"ho-enable", "1", "1",
+	"meas-rep", "0", "0","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_3[] = {
+	"2",
+
+	"Penalty timer must not run\n\n"
+	"The MS will try to handover to a better cell, but this will fail.\n"
+	"Even though the cell is still better, handover will not be performed\n"
+	"due to penalty timer after handover failure\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-failed",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-no-chan",
+	NULL
+};
+
+static char *test_case_4[] = {
+	"2",
+
+	"TCH/H keeping with HR codec\n\n"
+	"The MS is using half rate V1 codec, but the better cell is congested\n"
+	"at TCH/H slots. As the congestion is removed, the handover takes\n"
+	"place.\n",
+
+	"create-bts", "2",
+	"set-min-free", "1", "TCH/H", "4",
+	"create-ms", "0", "TCH/H", "HR",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-no-chan",
+	"set-min-free", "1", "TCH/H", "3",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-chan", "1", "5",
+	"ack-chan",
+	"expect-ho", "0", "5",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_5[] = {
+	"2",
+
+	"TCH/F keeping with FR codec\n\n"
+	"The MS is using full rate V1 codec, but the better cell is congested\n"
+	"at TCH/F slots. As the congestion is removed, the handover takes\n"
+	"place.\n",
+
+	"create-bts", "2",
+	"set-min-free", "1", "TCH/F", "4",
+	"create-ms", "0", "TCH/F", "FR",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-no-chan",
+	"set-min-free", "1", "TCH/F", "3",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_6[] = {
+	"2",
+
+	"TCH/F keeping with EFR codec\n\n"
+	"The MS is using full rate V2 codec, but the better cell is congested\n"
+	"at TCH/F slots. As the congestion is removed, the handover takes\n"
+	"place.\n",
+
+	"create-bts", "2",
+	"set-min-free", "1", "TCH/F", "4",
+	"create-ms", "0", "TCH/F", "EFR",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-no-chan",
+	"set-min-free", "1", "TCH/F", "3",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_7[] = {
+	"2",
+
+	"TCH/F to TCH/H changing with AMR codec\n\n"
+	"The MS is using AMR V3 codec, the better cell is congested at TCH/F\n"
+	"slots. The handover is performed to non-congested TCH/H slots.\n",
+
+	"create-bts", "2",
+	"set-min-free", "1", "TCH/F", "4",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-chan", "1", "5",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_8[] = {
+	"2",
+
+	"No handover to a cell with no slots available\n\n"
+	"If no slot is available, no handover is performed\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "1", "TCH/F", "AMR",
+	"create-ms", "1", "TCH/F", "AMR",
+	"create-ms", "1", "TCH/F", "AMR",
+	"create-ms", "1", "TCH/F", "AMR",
+	"create-ms", "1", "TCH/H", "AMR",
+	"create-ms", "1", "TCH/H", "AMR",
+	"create-ms", "1", "TCH/H", "AMR",
+	"create-ms", "1", "TCH/H", "AMR",
+	"meas-rep", "0", "0","0", "1","0","30",
+	"expect-no-chan",
+	NULL
+};
+
+static char *test_case_9[] = {
+	"2",
+
+	"No more parallel handovers, if max_unsync_ho is defined\n\n"
+	"There are tree mobiles that want to handover, but only two can do\n"
+	"it at a time, because the maximum number is limited to two.\n",
+
+	"create-bts", "2",
+	"set-max-ho", "1", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "0","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"meas-rep", "1", "0","0", "1","0","30",
+	"expect-chan", "1", "2",
+	"meas-rep", "2", "0","0", "1","0","30",
+	"expect-no-chan",
+	NULL
+};
+
+static char *test_case_10[] = {
+	"2",
+
+	"Hysteresis\n\n"
+	"If neighbor cell is better, handover is only performed if the\n"
+	"ammount of improvement is greater or equal hyteresis\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "27","0", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "26","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_11[] = {
+	"2",
+
+	"No Hysteresis and minimum RX level\n\n"
+	"If current cell's RX level is below mimium level, handover must be\n"
+	"performed, no matter of the hysteresis. First do not perform\n"
+	"handover to better neighbor cell, because the hysteresis is not\n"
+	"met. Second do not perform handover because better neighbor cell is\n"
+	"below minimum RX level. Third perform handover because current cell\n"
+	"is below minimum RX level, even if the better neighbor cell (minimum\n"
+	"RX level reached) does not meet the hysteresis.\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "10","0", "1","0","11",
+	"expect-no-chan",
+	"meas-rep", "0", "8","0", "1","0","9",
+	"expect-no-chan",
+	"meas-rep", "0", "9","0", "1","0","10",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_12[] = {
+	"2",
+
+	"No handover to congested cell\n\n"
+	"The better neighbor cell is congested, so no handover is performed.\n"
+	"After the congestion is over, handover will be performed.\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"set-min-free", "1", "TCH/F", "4",
+	"set-min-free", "1", "TCH/H", "4",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-no-chan",
+	"set-min-free", "1", "TCH/F", "3",
+	"set-min-free", "1", "TCH/H", "3",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_13[] = {
+	"2",
+
+	"Handover to balance congestion\n\n"
+	"The current and the better cell are congested, so no handover is\n"
+	"performed. This is because handover would congest the neighbor cell\n"
+	"more. After congestion raises in the current cell, the handover is\n"
+	"performed to balance congestion\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"set-min-free", "0", "TCH/F", "4",
+	"set-min-free", "0", "TCH/H", "4",
+	"set-min-free", "1", "TCH/F", "4",
+	"set-min-free", "1", "TCH/H", "4",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-no-chan",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_14[] = {
+	"2",
+
+	"Handover to congested cell, if RX level is below minimum\n\n"
+	"The better neighbor cell is congested, so no handover is performed.\n"
+	"If the RX level of the current cell drops below minimum acceptable\n"
+	"level, the handover is performed.\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"set-min-free", "1", "TCH/F", "4",
+	"set-min-free", "1", "TCH/H", "4",
+	"meas-rep", "0", "10","0", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "9","0", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_15[] = {
+	"2",
+
+	"Handover to cell with worse RXLEV, if RXQUAL is below minimum\n\n"
+	"The neighbor cell has worse RXLEV, so no handover is performed.\n"
+	"If the RXQUAL of the current cell drops below minimum acceptable\n"
+	"level, the handover is performed. It is also required that 10\n"
+	"reports are received, before RXQUAL is checked.\n",
+	/* (See also test 28, which tests for RXQUAL triggering HO to congested cell.) */
+	/* TODO: bad RXQUAL may want to prefer assignment within the same cell to avoid interference.
+	 * See Performence Enhancements in a Frequency Hopping GSM Network (Nielsen Wigard 2002), Chapter
+	 * 2.1.1, "Interference" in the list of triggers on p.157. */
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-no-chan",
+	"meas-rep", "0", "40","6", "1","0","30",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_16[] = {
+	"2",
+
+	"Handover due to maximum TA exceeded\n\n"
+	"The MS in the current (best) cell has reached maximum allowed timing\n"
+	"advance. No handover is performed until the timing advance exceeds\n"
+	"it. The originating cell is still the best, but no handover is\n"
+	"performed back to that cell, because the penalty timer (due to\n"
+	"maximum allowed timing advance) is running.\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"set-max-ta", "0", "5", /* of cell */
+	"set-ta", "0", "5", /* of ms */
+	"meas-rep", "0", "30","0", "1","0","20",
+	"expect-no-chan",
+	"set-ta", "0", "6", /* of ms */
+	"meas-rep", "0", "30","0", "1","0","20",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	"meas-rep", "0", "20","0", "1","0","30",
+	"expect-no-chan",
+	NULL
+};
+
+static char *test_case_17[] = {
+	"2",
+
+	"Congestion check: No congestion\n\n"
+	"Three cells have different number of used slots, but there is no\n"
+	"congestion in any of these cells. No handover is performed.\n",
+
+	"create-bts", "3",
+	"set-min-free", "0", "TCH/F", "2",
+	"set-min-free", "0", "TCH/H", "2",
+	"set-min-free", "1", "TCH/F", "2",
+	"set-min-free", "1", "TCH/H", "2",
+	"set-min-free", "2", "TCH/F", "2",
+	"set-min-free", "2", "TCH/H", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"create-ms", "1", "TCH/F", "AMR",
+	"create-ms", "1", "TCH/H", "AMR",
+	"meas-rep", "0", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "1", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "2", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "3", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "4", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "5", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-no-chan",
+	NULL
+};
+
+static char *test_case_18[] = {
+	"2",
+
+	"Congestion check: One out of three cells is congested\n\n"
+	"Three cells have different number of used slots, but there is\n"
+	"congestion at TCH/F in the first cell. Handover is performed with\n"
+	"the best candidate.\n",
+
+	"create-bts", "3",
+	"set-min-free", "0", "TCH/F", "2",
+	"set-min-free", "0", "TCH/H", "2",
+	"set-min-free", "1", "TCH/F", "2",
+	"set-min-free", "1", "TCH/H", "2",
+	"set-min-free", "2", "TCH/F", "2",
+	"set-min-free", "2", "TCH/H", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"create-ms", "1", "TCH/F", "AMR",
+	"create-ms", "1", "TCH/H", "AMR",
+	"meas-rep", "0", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "1", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "2", "30","0", "2","0","21","1","20",
+	"expect-no-chan",
+	"meas-rep", "3", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "4", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "5", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"meas-rep", "6", "30","0", "2","0","20","1","20",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-chan", "1", "2",
+	"ack-chan",
+	"expect-ho", "0", "3", /* best candidate is MS 2 at BTS 1, TS 3 */
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_19[] = {
+	"2",
+
+	"Congestion check: Balancing over congested cells\n\n"
+	"Two cells are congested, but the second cell is more congested.\n"
+	"Handover is performed to solve the congestion.\n",
+
+	"create-bts", "2",
+	"set-min-free", "0", "TCH/F", "4",
+	"set-min-free", "1", "TCH/F", "4",
+	"create-ms", "0", "TCH/F", "FR",
+	"create-ms", "0", "TCH/F", "FR",
+	"create-ms", "0", "TCH/F", "FR",
+	"create-ms", "1", "TCH/F", "FR",
+	"meas-rep", "0", "30","0", "1","0","20",
+	"expect-no-chan",
+	"meas-rep", "1", "30","0", "1","0","21",
+	"expect-no-chan",
+	"meas-rep", "2", "30","0", "1","0","20",
+	"expect-no-chan",
+	"meas-rep", "3", "30","0", "1","0","20",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-chan", "1", "2",
+	"ack-chan",
+	"expect-ho", "0", "2", /* best candidate is MS 1 at BTS 0, TS 2 */
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_20[] = {
+	"2",
+
+	"Congestion check: Solving congestion by handover TCH/F -> TCH/H\n\n"
+	"Two BTS, one MS in the first congested BTS must handover to\n"
+	"non-congested TCH/H of second BTS, in order to solve congestion\n",
+	"create-bts", "2",
+	"set-min-free", "0", "TCH/F", "4",
+	"set-min-free", "0", "TCH/H", "4",
+	"set-min-free", "1", "TCH/F", "4",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "30","0", "1","0","30",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-chan", "1", "5",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_21[] = {
+	"2",
+
+	"Congestion check: Balancing congestion by handover TCH/F -> TCH/H\n\n"
+	"Two BTS, one MS in the first congested BTS must handover to\n"
+	"less-congested TCH/H of second BTS, in order to balance congestion\n",
+	"create-bts", "2",
+	"set-min-free", "0", "TCH/F", "4",
+	"set-min-free", "0", "TCH/H", "4",
+	"set-min-free", "1", "TCH/F", "4",
+	"set-min-free", "1", "TCH/H", "4",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/F", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"meas-rep", "0", "30","0", "1","0","30",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_22[] = {
+	"2",
+
+	"Congestion check: Upgrading worst candidate from TCH/H -> TCH/F\n\n"
+	"There is only one BTS. The TCH/H slots are congested. Since\n"
+	"assignment is performed to less-congested TCH/F, the candidate with\n"
+	"the worst RX level is chosen.\n",
+
+	"create-bts", "1",
+	"set-min-free", "0", "TCH/F", "4",
+	"set-min-free", "0", "TCH/H", "4",
+	"create-ms", "0", "TCH/H", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"meas-rep", "0", "30","0", "0",
+	"meas-rep", "1", "34","0", "0",
+	"meas-rep", "2", "20","0", "0",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-chan", "0", "1",
+	"ack-chan",
+	"expect-ho", "0", "6",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_23[] = {
+	"2",
+
+	"Story: 'A neighbor is your friend'\n",
+
+	"create-bts", "3",
+
+	"print",
+	"Andreas is driving along the coast, on a sunny june afternoon.\n"
+	"Suddenly he is getting a call from his friend and neighbor Axel.\n"
+	"\n"
+	"What happens: Two MS are created, #0 for Axel, #1 for Andreas.",
+	/* Axel */
+	"create-ms", "2", "TCH/F", "AMR",
+	/* andreas */
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "1", "40","0", "1","0","30",
+	"expect-no-chan",
+
+	"print",
+	"Axel asks Andreas if he would like to join them for a barbecue.\n"
+	"Axel's house is right in the neighborhood and the weather is fine.\n"
+	"Andreas agrees, so he drives to a close store to buy some barbecue\n"
+	"skewers.\n"
+	"\n"
+	"What happens: While driving, a different cell (mounted atop the\n"
+	"store) becomes better.",
+	/* drive to bts 1 */
+	"meas-rep", "1", "20","0", "1","0","35",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+
+	"print",
+	"While Andreas is walking into the store, Axel asks, if he could also\n"
+	"bring some beer. Andreas has problems understanding him: \"I have a\n"
+	"bad reception here. The cell tower is right atop the store, but poor\n"
+	"coverage inside. Can you repeat please?\"\n"
+	"\n"
+	"What happens: Inside the store the close cell is so bad, that\n"
+	"handover back to the previous cell is required.",
+	/* bts 1 becomes bad, so bts 0 helps out */
+	"meas-rep", "1", "5","0", "1","0","20",
+	"expect-chan", "0", "1",
+	"ack-chan",
+	"expect-ho", "1", "1",
+	"ho-complete",
+
+	"print",
+	"After Andreas bought skewers and beer, he leaves the store.\n"
+	"\n"
+	"What happens: Outside the store the close cell is better again, so\n"
+	"handover back to the that cell is performed.",
+	/* bts 1 becomes better again */
+	"meas-rep", "1", "20","0", "1","0","35",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+
+	"print",
+	/* bts 2 becomes better */
+	"Andreas drives down to the lake where Axel's house is.\n"
+	"\n"
+	"What happens: There is a small cell at Axel's house, which becomes\n"
+	"better, because the current cell has no good comverage at the lake.",
+	"meas-rep", "1", "14","0", "2","0","2","1","63",
+	"expect-chan", "2", "2",
+	"ack-chan",
+	"expect-ho", "1", "1",
+	"ho-complete",
+
+	"print",
+	"Andreas wonders why he still has good radio coverage: \"Last time it\n"
+	"was so bad\". Axel says: \"I installed a pico cell in my house,\n"
+	"now we can use our mobile phones down here at the lake.\"",
+
+	NULL
+};
+
+static char *test_case_24[] = {
+	"2",
+	"No (or not enough) measurements for handover\n\n"
+	"Do not solve congestion in cell, because there is no measurement.\n"
+	"As soon as enough measurments available (1 in our case), perform\n"
+	"handover. Afterwards the old cell becomes congested and the new\n"
+	"cell is not. Do not perform handover until new measurements are\n"
+	"received.\n",
+
+	/* two cells, first in congested, but no handover */
+	"create-bts", "2",
+	"set-min-free", "0", "TCH/F", "4",
+	"set-min-free", "0", "TCH/H", "4",
+	"create-ms", "0", "TCH/F", "AMR",
+	"congestion-check",
+	"expect-no-chan",
+
+	/* send measurement and trigger congestion check */
+	"meas-rep", "0", "20","0", "1","0","20",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+
+	/* congest the first cell and remove congestion from second cell */
+	"set-min-free", "0", "TCH/F", "0",
+	"set-min-free", "0", "TCH/H", "0",
+	"set-min-free", "1", "TCH/F", "4",
+	"set-min-free", "1", "TCH/H", "4",
+
+	/* no handover until measurements applied */
+	"congestion-check",
+	"expect-no-chan",
+	"meas-rep", "0", "20","0", "1","0","20",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-chan", "0", "1",
+	"ack-chan",
+	"expect-ho", "1", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_25[] = {
+	"1",
+
+	"Stay in better cell\n\n"
+	"There are many neighbor cells, but only the current cell is the best\n"
+	"cell, so no handover is performed\n",
+
+	"create-bts", "7",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "30","0",
+		"6","0","20","1","21","2","18","3","20","4","23","5","19",
+	"expect-no-chan",
+	NULL
+};
+
+static char *test_case_26[] = {
+	"1",
+
+	"Handover to best better cell\n\n"
+	"The best neighbor cell is selected\n",
+
+	"create-bts", "7",
+	"create-ms", "0", "TCH/F", "AMR",
+	"meas-rep", "0", "10","0",
+		"6","0","20","1","21","2","18","3","20","4","23","5","19",
+	"expect-chan", "5", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char *test_case_27[] = {
+	"2",
+
+	"Congestion check: Upgrading worst candidate from TCH/H -> TCH/F\n\n"
+	"There is only one BTS. The TCH/H slots are congested. Since\n"
+	"assignment is performed to less-congested TCH/F, the candidate with\n"
+	"the worst RX level is chosen. (So far like test 22.)\n"
+	"After that, trigger more congestion checks to ensure stability.\n",
+
+	"create-bts", "1",
+	"set-min-free", "0", "TCH/F", "2",
+	"set-min-free", "0", "TCH/H", "4",
+	"create-ms", "0", "TCH/H", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"create-ms", "0", "TCH/H", "AMR",
+	"meas-rep", "0", "30","0", "0",
+	"meas-rep", "1", "34","0", "0",
+	"meas-rep", "2", "20","0", "0",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-chan", "0", "1",
+	"ack-chan",
+	"expect-ho", "0", "6",
+	"ho-complete",
+	"congestion-check",
+	"expect-chan", "0", "2",
+	"ack-chan",
+	"expect-ho", "0", "5",
+	"ho-complete",
+	"congestion-check",
+	"expect-no-chan",
+	"congestion-check",
+	"expect-no-chan",
+	NULL
+};
+
+static char *test_case_28[] = {
+	"2",
+
+	"Handover to congested cell, if RX quality is below minimum\n\n"
+	"The better neighbor cell is congested, so no handover is performed.\n"
+	"If the RX quality of the current cell drops below minimum acceptable\n"
+	"level, the handover is performed. It is also required that 10\n"
+	"resports are received, before RX quality is checked.\n",
+
+	"create-bts", "2",
+	"create-ms", "0", "TCH/F", "AMR",
+	"set-min-free", "1", "TCH/F", "4",
+	"set-min-free", "1", "TCH/H", "4",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-no-chan",
+	"meas-rep", "0", "30","6", "1","0","40",
+	"expect-chan", "1", "1",
+	"ack-chan",
+	"expect-ho", "0", "1",
+	"ho-complete",
+	NULL
+};
+
+static char **test_cases[] =  {
+	test_case_0,
+	test_case_1,
+	test_case_2,
+	test_case_3,
+	test_case_4,
+	test_case_5,
+	test_case_6,
+	test_case_7,
+	test_case_8,
+	test_case_9,
+	test_case_10,
+	test_case_11,
+	test_case_12,
+	test_case_13,
+	test_case_14,
+	test_case_15,
+	test_case_16,
+	test_case_17,
+	test_case_18,
+	test_case_19,
+	test_case_20,
+	test_case_21,
+	test_case_22,
+	test_case_23,
+	test_case_24,
+	test_case_25,
+	test_case_26,
+	test_case_27,
+	test_case_28,
+	NULL
+};
+
+static const struct log_info_cat log_categories[] = {
+	[DHO] = {
+		.name = "DHO",
+		.description = "Hand-Over Process",
+		.color = "\033[1;38m",
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+	[DHODEC] = {
+		.name = "DHODEC",
+		.description = "Hand-Over Decision",
+		.color = "\033[1;38m",
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+	[DMEAS] = {
+		.name = "DMEAS",
+		.description = "Radio Measurement Processing",
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+	[DREF] = {
+		.name = "DREF",
+		.description = "Reference Counting",
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+	[DRSL] = {
+		.name = "DRSL",
+		.description = "A-bis Radio Siganlling Link (RSL)",
+		.color = "\033[1;35m",
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+};
+
+const struct log_info log_info = {
+	.cat = log_categories,
+	.num_cat = ARRAY_SIZE(log_categories),
+};
+
+int main(int argc, char **argv)
+{
+	char **test_case;
+	struct gsm_bts *bts[256];
+	int bts_num = 0;
+	struct gsm_lchan *lchan[256];
+	int lchan_num = 0;
+	int test_count = 0;
+	int i;
+	int algorithm;
+	struct bsc_api bsc_api = {};
+
+	for (i = 0; test_cases[i]; i++)
+		test_count++;
+
+	if (argc <= 1 || atoi(argv[1]) >= test_count) {
+		for (i = 0; test_cases[i]; i++) {
+			printf("Test #%d (algorithm %s):\n%s\n", i,
+				test_cases[i][0], test_cases[i][1]);
+		}
+		printf("\nPlease specify test case number 0..%d\n",
+			test_count - 1);
+		return EXIT_FAILURE;
+	}
+
+	osmo_init_logging(&log_info);
+
+	log_set_print_category(osmo_stderr_target, 1);
+	log_set_print_category_hex(osmo_stderr_target, 0);
+	log_set_print_filename2(osmo_stderr_target, LOG_FILENAME_BASENAME);
+
+	/* Create a dummy network */
+	bsc_gsmnet = bsc_network_init(NULL, 1, 1);
+	if (!bsc_gsmnet)
+		exit(1);
+
+	bsc_api_init(bsc_gsmnet, &bsc_api);
+
+	ho_set_algorithm(bsc_gsmnet->ho, 2);
+	ho_set_ho_active(bsc_gsmnet->ho, true);
+	ho_set_hodec2_as_active(bsc_gsmnet->ho, true);
+	ho_set_hodec2_min_rxlev(bsc_gsmnet->ho, -100);
+	ho_set_hodec2_rxlev_avg_win(bsc_gsmnet->ho, 1);
+	ho_set_hodec2_rxlev_neigh_avg_win(bsc_gsmnet->ho, 1);
+	ho_set_hodec2_rxqual_avg_win(bsc_gsmnet->ho, 10);
+	ho_set_hodec2_pwr_hysteresis(bsc_gsmnet->ho, 3);
+	ho_set_hodec2_pwr_interval(bsc_gsmnet->ho, 1);
+	ho_set_hodec2_afs_bias_rxlev(bsc_gsmnet->ho, 0);
+	ho_set_hodec2_min_rxqual(bsc_gsmnet->ho, 5);
+	ho_set_hodec2_afs_bias_rxqual(bsc_gsmnet->ho, 0);
+	ho_set_hodec2_max_distance(bsc_gsmnet->ho, 9999);
+	ho_set_hodec2_ho_max(bsc_gsmnet->ho, 9999);
+	ho_set_hodec2_penalty_max_dist(bsc_gsmnet->ho, 300);
+	ho_set_hodec2_penalty_failed_ho(bsc_gsmnet->ho, 60);
+	ho_set_hodec2_penalty_failed_as(bsc_gsmnet->ho, 60);
+
+	bts_model_sysmobts_init();
+
+	test_case = test_cases[atoi(argv[1])];
+
+	fprintf(stderr, "--------------------\n");
+	fprintf(stderr, "Performing the following test %d (algorithm %s):\n%s",
+		atoi(argv[1]), test_case[0], test_case[1]);
+	algorithm = atoi(test_case[0]);
+	test_case += 2;
+	fprintf(stderr, "--------------------\n");
+
+	/* Disable the congestion check timer, we will trigger manually. */
+	bsc_gsmnet->hodec2.congestion_check_interval_s = 0;
+
+	handover_decision_1_init();
+	hodec2_init(bsc_gsmnet);
+
+	while (*test_case) {
+		if (!strcmp(*test_case, "create-bts")) {
+			static int arfcn = 870;
+			int n = atoi(test_case[1]);
+			fprintf(stderr, "- Creating %d BTS (one TRX each, "
+				"TS(1-4) are TCH/F, TS(5-6) are TCH/H)\n", n);
+			for (i = 0; i < n; i++)
+				bts[bts_num + i] = create_bts(arfcn++);
+			for (i = 0; i < n; i++)
+				gsm_generate_si(bts[bts_num + i],
+					SYSINFO_TYPE_2);
+			bts_num += n;
+			test_case += 2;
+		} else
+		if (!strcmp(*test_case, "as-enable")) {
+			fprintf(stderr, "- Set assignment enable state at "
+				"BTS %s to %s\n", test_case[1], test_case[2]);
+			ho_set_hodec2_as_active(bts[atoi(test_case[1])]->ho, atoi(test_case[2]));
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "ho-enable")) {
+			fprintf(stderr, "- Set handover enable state at "
+				"BTS %s to %s\n", test_case[1], test_case[2]);
+			ho_set_ho_active(bts[atoi(test_case[1])]->ho, atoi(test_case[2]));
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "afs-rxlev-improve")) {
+			fprintf(stderr, "- Set afs RX level improvement at "
+				"BTS %s to %s\n", test_case[1], test_case[2]);
+			ho_set_hodec2_afs_bias_rxlev(bts[atoi(test_case[1])]->ho, atoi(test_case[2]));
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "afs-rxqual-improve")) {
+			fprintf(stderr, "- Set afs RX quality improvement at "
+				"BTS %s to %s\n", test_case[1], test_case[2]);
+			ho_set_hodec2_afs_bias_rxqual(bts[atoi(test_case[1])]->ho, atoi(test_case[2]));
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "set-min-free")) {
+			fprintf(stderr, "- Setting minimum required free %s "
+				"slots at BTS %s to %s\n", test_case[2],
+				test_case[1], test_case[3]);
+			if (!strcmp(test_case[2], "TCH/F"))
+				ho_set_hodec2_tchf_min_slots(bts[atoi(test_case[1])]->ho, atoi(test_case[3]));
+			else
+				ho_set_hodec2_tchh_min_slots(bts[atoi(test_case[1])]->ho, atoi(test_case[3]));
+			test_case += 4;
+		} else
+		if (!strcmp(*test_case, "set-max-ho")) {
+			fprintf(stderr, "- Setting maximum parallel handovers "
+				"at BTS %s to %s\n", test_case[1],
+				test_case[2]);
+			ho_set_hodec2_ho_max( bts[atoi(test_case[1])]->ho, atoi(test_case[2]));
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "set-max-ta")) {
+			fprintf(stderr, "- Setting maximum timing advance "
+				"at BTS %s to %s\n", test_case[1],
+				test_case[2]);
+			ho_set_hodec2_max_distance(bts[atoi(test_case[1])]->ho, atoi(test_case[2]));
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "create-ms")) {
+			fprintf(stderr, "- Creating mobile #%d at BTS %s on "
+				"%s with %s codec\n", lchan_num, test_case[1],
+				test_case[2], test_case[3]);
+			lchan[lchan_num] = create_lchan(bts[atoi(test_case[1])],
+				!strcmp(test_case[2], "TCH/F"), test_case[3]);
+			if (!lchan[lchan_num]) {
+				printf("Failed to create lchan!\n");
+				return EXIT_FAILURE;
+			}
+			fprintf(stderr, " * New MS is at BTS %d TS %d\n",
+				lchan[lchan_num]->ts->trx->bts->nr,
+				lchan[lchan_num]->ts->nr);
+			lchan_num++;
+			test_case += 4;
+		} else
+		if (!strcmp(*test_case, "set-ta")) {
+			fprintf(stderr, "- Setting maximum timing advance "
+				"at MS %s to %s\n", test_case[1],
+				test_case[2]);
+			meas_ta_ms = atoi(test_case[2]);
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "meas-rep")) {
+			/* meas-rep <lchan-nr> <rxlev> <rxqual> <nr-of-neighbors> [<cell-idx> <rxlev> [...]] */
+			int n = atoi(test_case[4]);
+			struct gsm_lchan *lc = lchan[atoi(test_case[1])];
+			fprintf(stderr, "- Sending measurement report from "
+				"mobile #%s (rxlev=%s, rxqual=%s)\n",
+				test_case[1], test_case[2], test_case[3]);
+			meas_dl_rxlev = atoi(test_case[2]);
+			meas_dl_rxqual = atoi(test_case[3]);
+			meas_num_nc = n;
+			test_case += 5;
+			for (i = 0; i < n; i++) {
+				int nr = atoi(test_case[0]);
+				/* since our bts is not in the list of neighbor
+				 * cells, we need to shift */
+				if (nr >= lc->ts->trx->bts->nr)
+					nr++;
+				fprintf(stderr, " * Neighbor cell #%s, actual "
+					"BTS %d (rxlev=%s)\n", test_case[0], nr,
+					test_case[1]);
+				meas_bcch_f_nc[i] = atoi(test_case[0]);
+					/* bts number, not counting our own */
+				meas_rxlev_nc[i] = atoi(test_case[1]);
+				meas_bsic_nc[i] = 0x3f;
+				test_case += 2;
+			}
+			got_chan_req = 0;
+			gen_meas_rep(lc);
+		} else
+		if (!strcmp(*test_case, "congestion-check")) {
+			fprintf(stderr, "- Triggering congestion check\n");
+			got_chan_req = 0;
+			if (algorithm == 2)
+				hodec2_congestion_check(bsc_gsmnet);
+			test_case += 1;
+		} else
+		if (!strcmp(*test_case, "expect-chan")) {
+			fprintf(stderr, "- Expecting channel request at BTS %s "
+				"TS %s\n", test_case[1], test_case[2]);
+			if (!got_chan_req) {
+				printf("Test failed, because no channel was "
+					"requested\n");
+				return EXIT_FAILURE;
+			}
+			fprintf(stderr, " * Got channel request at BTS %d "
+				"TS %d\n", chan_req_lchan->ts->trx->bts->nr,
+				chan_req_lchan->ts->nr);
+			if (chan_req_lchan->ts->trx->bts->nr
+						!= atoi(test_case[1])) {
+				printf("Test failed, because channel was not "
+					"requested on expected BTS\n");
+				return EXIT_FAILURE;
+			}
+			if (chan_req_lchan->ts->nr != atoi(test_case[2])) {
+				printf("Test failed, because channel was not "
+					"requested on expected TS\n");
+				return EXIT_FAILURE;
+			}
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "expect-no-chan")) {
+			fprintf(stderr, "- Expecting no channel request\n");
+			if (got_chan_req) {
+				fprintf(stderr, " * Got channel request at "
+					"BTS %d TS %d\n",
+					chan_req_lchan->ts->trx->bts->nr,
+					chan_req_lchan->ts->nr);
+				printf("Test failed, because channel was "
+					"requested\n");
+				return EXIT_FAILURE;
+			}
+			fprintf(stderr, " * Got no channel request\n");
+			test_case += 1;
+		} else
+		if (!strcmp(*test_case, "expect-ho")) {
+			fprintf(stderr, "- Expecting handover/assignment "
+				"request at BTS %s TS %s\n", test_case[1],
+				test_case[2]);
+			if (!got_ho_req) {
+				printf("Test failed, because no handover was "
+					"requested\n");
+				return EXIT_FAILURE;
+			}
+			fprintf(stderr, " * Got handover/assignment request at "
+				"BTS %d TS %d\n",
+				ho_req_lchan->ts->trx->bts->nr,
+				ho_req_lchan->ts->nr);
+			if (ho_req_lchan->ts->trx->bts->nr
+							!= atoi(test_case[1])) {
+				printf("Test failed, because "
+					"handover/assignment was not commanded "
+					"at the expected BTS\n");
+				return EXIT_FAILURE;
+			}
+			if (ho_req_lchan->ts->nr != atoi(test_case[2])) {
+				printf("Test failed, because "
+					"handover/assignment was not commanded "
+					"at the expected TS\n");
+				return EXIT_FAILURE;
+			}
+			test_case += 3;
+		} else
+		if (!strcmp(*test_case, "ack-chan")) {
+			fprintf(stderr, "- Acknowledging channel request\n");
+			if (!got_chan_req) {
+				printf("Cannot ack channel, because no "
+					"request\n");
+				return EXIT_FAILURE;
+			}
+			test_case += 1;
+			got_ho_req = 0;
+			send_chan_act_ack(chan_req_lchan, 1);
+		} else
+		if (!strcmp(*test_case, "ho-complete")) {
+			fprintf(stderr, "- Acknowledging handover/assignment "
+				"request\n");
+			if (!got_chan_req) {
+				printf("Cannot ack handover/assignment, "
+					"because no chan request\n");
+				return EXIT_FAILURE;
+			}
+			if (!got_ho_req) {
+				printf("Cannot ack handover/assignment, "
+					"because no ho request\n");
+				return EXIT_FAILURE;
+			}
+			test_case += 1;
+			got_chan_req = 0;
+			got_ho_req = 0;
+			/* switch lchan */
+			for (i = 0; i < lchan_num; i++) {
+				if (lchan[i] == ho_req_lchan) {
+					fprintf(stderr, " * MS %d changes from "
+						"BTS=%d TS=%d to BTS=%d "
+						"TS=%d\n", i,
+						lchan[i]->ts->trx->bts->nr,
+						lchan[i]->ts->nr,
+					       chan_req_lchan->ts->trx->bts->nr,
+						chan_req_lchan->ts->nr);
+					lchan[i] = chan_req_lchan;
+				}
+			}
+			send_ho_complete(chan_req_lchan, true);
+		} else
+		if (!strcmp(*test_case, "ho-failed")) {
+			fprintf(stderr, "- Making handover fail\n");
+			if (!got_chan_req) {
+				printf("Cannot fail handover, because no chan "
+					"request\n");
+				return EXIT_FAILURE;
+			}
+			test_case += 1;
+			got_chan_req = 0;
+			got_ho_req = 0;
+			send_ho_complete(ho_req_lchan, false);
+		} else
+		if (!strcmp(*test_case, "print")) {
+			fprintf(stderr, "\n%s\n\n", test_case[1]);
+			test_case += 2;
+		} else {
+			printf("Unknown test command '%s', please fix!\n",
+				*test_case);
+			return EXIT_FAILURE;
+		}
+	}
+
+	for (i = 0; i < lchan_num; i++) {
+		struct gsm_subscriber_connection *conn = lchan[i]->conn;
+		lchan[i]->conn = NULL;
+		conn->lchan = NULL;
+		bsc_subscr_con_free(conn);
+		lchan_free(lchan[i]);
+	}
+
+	fprintf(stderr, "--------------------\n");
+
+	printf("Test OK\n");
+
+	fprintf(stderr, "--------------------\n");
+
+	return EXIT_SUCCESS;
+}
+
+void rtp_socket_free() {}
+void rtp_send_frame() {}
+void rtp_socket_upstream() {}
+void rtp_socket_create() {}
+void rtp_socket_connect() {}
+void rtp_socket_proxy() {}
+void trau_mux_unmap() {}
+void trau_mux_map_lchan() {}
+void trau_recv_lchan() {}
+void trau_send_frame() {}