diff --git a/tests/codec_pref/codec_pref_test.c b/tests/codec_pref/codec_pref_test.c
index 73547ad..385854f 100644
--- a/tests/codec_pref/codec_pref_test.c
+++ b/tests/codec_pref/codec_pref_test.c
@@ -270,9 +270,62 @@
 	}
 }
 
+/* Generate a realitically looking bts codec configuration */
+static void make_bts_config(struct gsm_bts *bts, uint8_t config_no)
+{
+	/* Note: FR is supported by all BTSs, so there is no flag for it */
+
+	OSMO_ASSERT(config_no < N_CONFIG_VARIANTS);
+
+	bts->codec.hr = 0;
+	bts->codec.efr = 0;
+	bts->codec.amr = 0;
+
+	switch (config_no) {
+	case 0:
+		/* FR1 (implicit) only */
+		break;
+	case 1:
+		/* HR1 only (+FR implicit) */
+		bts->codec.hr = 1;
+		break;
+	case 2:
+		/* FR2 only (+FR implicit)  */
+		bts->codec.efr = 1;
+		break;
+	case 3:
+		/* FR3 only (+FR implicit) */
+		bts->codec.amr = 1;
+		break;
+	case 4:
+		/* HR3 only (+FR implicit) */
+		bts->codec.amr = 1;
+		break;
+	case 5:
+		/* FR1 (implicit) and HR1 */
+		bts->codec.hr = 1;
+		break;
+	case 6:
+		/* FR1 (implicit), FR2 and HR1 */
+		bts->codec.efr = 1;
+		bts->codec.hr = 1;
+		break;
+	case 7:
+		/* FR1 (implicit), FR3 and HR3 */
+		bts->codec.amr = 1;
+		break;
+	case 8:
+		/* FR1 (implicit), FR2, FR3, HR1 and HR3 */
+		bts->codec.hr = 1;
+		bts->codec.efr = 1;
+		bts->codec.amr = 1;
+		break;
+	}
+}
+
 /* Try execute match_codec_pref(), display input and output parameters */
-static int test_match_codec_pref(const struct gsm0808_channel_type *ct,
-				 const struct gsm0808_speech_codec_list *scl, const struct bsc_msc_data *msc)
+static int test_match_codec_pref(const struct gsm0808_channel_type *ct, const struct gsm0808_speech_codec_list *scl,
+				 const struct bsc_msc_data *msc, struct gsm_bts *bts)
 {
 	int rc;
 	unsigned int i;
@@ -296,7 +349,13 @@
 		else
 			printf("   audio_support[%u]=FR%u\n", i, msc->audio_support[i]->ver);
 
-	rc = match_codec_pref(&full_rate, &chan_mode, ct, scl, msc);
+	printf(" * BTS: audio support settings:\n");
+	printf("   (GSM-FR implicitly supported)\n");
+	printf("   codec->hr=%u\n", bts->codec.hr);
+	printf("   codec->efr=%u\n", bts->codec.efr);
+	printf("   codec->amr=%u\n", bts->codec.amr);
+
+	rc = match_codec_pref(&full_rate, &chan_mode, ct, scl, msc, bts);
 	printf(" * result: rc=%i, full_rate=%i, chan_mode=%s\n", rc, full_rate, gsm48_chan_mode_name(chan_mode));
 
 	printf("\n");
@@ -311,6 +370,7 @@
 	struct gsm0808_channel_type ct_msc;
 	struct gsm0808_speech_codec_list scl_ms;
 	struct bsc_msc_data msc_local;
+	struct gsm_bts bts_local;
 	int rc;
 
 	printf("============== test_one_to_one ==============\n\n");
@@ -321,7 +381,8 @@
 		make_msc_config(&msc_local, i);
 		make_scl_config(&scl_ms, i);
 		make_ct_config(&ct_msc, i);
-		rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+		make_bts_config(&bts_local, i);
+		rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 		OSMO_ASSERT(rc == 0);
 	}
 
@@ -335,6 +396,7 @@
 	struct gsm0808_channel_type ct_msc;
 	struct gsm0808_speech_codec_list scl_ms;
 	struct bsc_msc_data msc_local;
+	struct gsm_bts bts_local;
 	int rc;
 
 	printf("============== test_ms ==============\n\n");
@@ -343,9 +405,10 @@
 
 	make_msc_config(&msc_local, 8);
 	make_ct_config(&ct_msc, 8);
+	make_bts_config(&bts_local, 8);
 	for (i = 0; i < N_CONFIG_VARIANTS; i++) {
 		make_scl_config(&scl_ms, i);
-		rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+		rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 		OSMO_ASSERT(rc == 0);
 	}
 
@@ -359,6 +422,7 @@
 	struct gsm0808_channel_type ct_msc;
 	struct gsm0808_speech_codec_list scl_ms;
 	struct bsc_msc_data msc_local;
+	struct gsm_bts bts_local;
 	int rc;
 
 	printf("============== test_ct ==============\n\n");
@@ -367,9 +431,10 @@
 
 	make_msc_config(&msc_local, 8);
 	make_scl_config(&scl_ms, 8);
+	make_bts_config(&bts_local, 8);
 	for (i = 0; i < N_CONFIG_VARIANTS; i++) {
 		make_ct_config(&ct_msc, i);
-		rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+		rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 		OSMO_ASSERT(rc == 0);
 	}
 
@@ -383,6 +448,7 @@
 	struct gsm0808_channel_type ct_msc;
 	struct gsm0808_speech_codec_list scl_ms;
 	struct bsc_msc_data msc_local;
+	struct gsm_bts bts_local;
 	int rc;
 
 	printf("============== test_msc ==============\n\n");
@@ -391,9 +457,10 @@
 
 	make_ct_config(&ct_msc, 8);
 	make_scl_config(&scl_ms, 8);
+	make_bts_config(&bts_local, 8);
 	for (i = 0; i < N_CONFIG_VARIANTS; i++) {
 		make_msc_config(&msc_local, 8);
-		rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+		rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 		OSMO_ASSERT(rc == 0);
 	}
 
@@ -406,6 +473,7 @@
 	struct gsm0808_channel_type ct_msc;
 	struct gsm0808_speech_codec_list scl_ms;
 	struct bsc_msc_data msc_local;
+	struct gsm_bts bts_local;
 	int rc;
 
 	printf("============== test_selected_working ==============\n\n");
@@ -415,19 +483,43 @@
 	make_scl_config(&scl_ms, 6);
 	make_ct_config(&ct_msc, 5);
 	make_msc_config(&msc_local, 7);
-	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+	make_bts_config(&bts_local, 8);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 	OSMO_ASSERT(rc == 0);
 
 	make_scl_config(&scl_ms, 0);
 	make_ct_config(&ct_msc, 5);
 	make_msc_config(&msc_local, 7);
-	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+	make_bts_config(&bts_local, 8);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 	OSMO_ASSERT(rc == 0);
 
 	make_scl_config(&scl_ms, 1);
 	make_ct_config(&ct_msc, 5);
 	make_msc_config(&msc_local, 6);
-	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+	make_bts_config(&bts_local, 8);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
+	OSMO_ASSERT(rc == 0);
+
+	make_scl_config(&scl_ms, 6);
+	make_ct_config(&ct_msc, 5);
+	make_msc_config(&msc_local, 7);
+	make_bts_config(&bts_local, 4);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
+	OSMO_ASSERT(rc == 0);
+
+	make_scl_config(&scl_ms, 0);
+	make_ct_config(&ct_msc, 5);
+	make_msc_config(&msc_local, 7);
+	make_bts_config(&bts_local, 2);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
+	OSMO_ASSERT(rc == 0);
+
+	make_scl_config(&scl_ms, 1);
+	make_ct_config(&ct_msc, 5);
+	make_msc_config(&msc_local, 6);
+	make_bts_config(&bts_local, 1);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 	OSMO_ASSERT(rc == 0);
 
 	free_msc_config(&msc_local);
@@ -439,6 +531,7 @@
 	struct gsm0808_channel_type ct_msc;
 	struct gsm0808_speech_codec_list scl_ms;
 	struct bsc_msc_data msc_local;
+	struct gsm_bts bts_local;
 	int rc;
 
 	printf("============== test_selected_non_working ==============\n\n");
@@ -448,19 +541,43 @@
 	make_scl_config(&scl_ms, 1);
 	make_ct_config(&ct_msc, 5);
 	make_msc_config(&msc_local, 7);
-	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+	make_bts_config(&bts_local, 8);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 	OSMO_ASSERT(rc == -1);
 
 	make_scl_config(&scl_ms, 1);
 	make_ct_config(&ct_msc, 5);
 	make_msc_config(&msc_local, 7);
-	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+	make_bts_config(&bts_local, 8);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 	OSMO_ASSERT(rc == -1);
 
 	make_scl_config(&scl_ms, 1);
 	make_ct_config(&ct_msc, 4);
 	make_msc_config(&msc_local, 6);
-	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local);
+	make_bts_config(&bts_local, 8);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
+	OSMO_ASSERT(rc == -1);
+
+	make_scl_config(&scl_ms, 1);
+	make_ct_config(&ct_msc, 2);
+	make_msc_config(&msc_local, 7);
+	make_bts_config(&bts_local, 8);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
+	OSMO_ASSERT(rc == -1);
+
+	make_scl_config(&scl_ms, 1);
+	make_ct_config(&ct_msc, 5);
+	make_msc_config(&msc_local, 4);
+	make_bts_config(&bts_local, 8);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
+	OSMO_ASSERT(rc == -1);
+
+	make_scl_config(&scl_ms, 8);
+	make_ct_config(&ct_msc, 4);
+	make_msc_config(&msc_local, 6);
+	make_bts_config(&bts_local, 7);
+	rc = test_match_codec_pref(&ct_msc, &scl_ms, &msc_local, &bts_local);
 	OSMO_ASSERT(rc == -1);
 
 	free_msc_config(&msc_local);
diff --git a/tests/codec_pref/codec_pref_test.ok b/tests/codec_pref/codec_pref_test.ok
index f97fbb1..d3cd028 100644
--- a/tests/codec_pref/codec_pref_test.ok
+++ b/tests/codec_pref/codec_pref_test.ok
@@ -7,6 +7,11 @@
    perm_spch[0]=FR1
  * BSS: audio support settings (1 items):
    audio_support[0]=FR1
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=0
+   codec->efr=0
+   codec->amr=0
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -16,6 +21,11 @@
    perm_spch[0]=HR1
  * BSS: audio support settings (1 items):
    audio_support[0]=HR1
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=0
+   codec->amr=0
  * result: rc=0, full_rate=0, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -25,6 +35,11 @@
    perm_spch[0]=FR2
  * BSS: audio support settings (1 items):
    audio_support[0]=FR2
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=0
+   codec->efr=1
+   codec->amr=0
  * result: rc=0, full_rate=1, chan_mode=SPEECH_EFR
 
 Determining channel mode and rate:
@@ -34,6 +49,11 @@
    perm_spch[0]=FR3
  * BSS: audio support settings (1 items):
    audio_support[0]=FR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=0
+   codec->efr=0
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_AMR
 
 Determining channel mode and rate:
@@ -43,6 +63,11 @@
    perm_spch[0]=HR3
  * BSS: audio support settings (1 items):
    audio_support[0]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=0
+   codec->efr=0
+   codec->amr=1
  * result: rc=0, full_rate=0, chan_mode=SPEECH_AMR
 
 Determining channel mode and rate:
@@ -55,6 +80,11 @@
  * BSS: audio support settings (2 items):
    audio_support[0]=FR1
    audio_support[1]=HR1
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=0
+   codec->amr=0
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -70,6 +100,11 @@
    audio_support[0]=FR1
    audio_support[1]=FR2
    audio_support[2]=HR1
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=0
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -85,6 +120,11 @@
    audio_support[0]=FR1
    audio_support[1]=FR3
    audio_support[2]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=0
+   codec->efr=0
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -106,6 +146,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 ============== test_ms ==============
@@ -125,6 +170,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -142,6 +192,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=0, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -159,6 +214,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_EFR
 
 Determining channel mode and rate:
@@ -176,6 +236,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_AMR
 
 Determining channel mode and rate:
@@ -193,6 +258,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=0, chan_mode=SPEECH_AMR
 
 Determining channel mode and rate:
@@ -211,6 +281,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -230,6 +305,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -249,6 +329,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -270,6 +355,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 ============== test_ct ==============
@@ -289,6 +379,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -306,6 +401,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=0, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -323,6 +423,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_EFR
 
 Determining channel mode and rate:
@@ -340,6 +445,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_AMR
 
 Determining channel mode and rate:
@@ -357,6 +467,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=0, chan_mode=SPEECH_AMR
 
 Determining channel mode and rate:
@@ -375,6 +490,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -394,6 +514,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -413,6 +538,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -434,6 +564,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 ============== test_msc ==============
@@ -457,6 +592,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -478,6 +618,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -499,6 +644,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -520,6 +670,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -541,6 +696,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -562,6 +722,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -583,6 +748,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -604,6 +774,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -625,6 +800,11 @@
    audio_support[2]=FR3
    audio_support[3]=HR1
    audio_support[4]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 ============== test_selected_working ==============
@@ -641,6 +821,11 @@
    audio_support[0]=FR1
    audio_support[1]=FR3
    audio_support[2]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -653,6 +838,11 @@
    audio_support[0]=FR1
    audio_support[1]=FR3
    audio_support[2]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
 
 Determining channel mode and rate:
@@ -665,6 +855,64 @@
    audio_support[0]=FR1
    audio_support[1]=FR2
    audio_support[2]=HR1
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
+ * result: rc=0, full_rate=0, chan_mode=SPEECH_V1
+
+Determining channel mode and rate:
+ * MS: speech codec list (3 items):
+   codec[0]->type=FR1
+   codec[1]->type=FR2
+   codec[2]->type=HR1
+ * MSC: channel type permitted speech (2 items):
+   perm_spch[0]=FR1
+   perm_spch[1]=HR1
+ * BSS: audio support settings (3 items):
+   audio_support[0]=FR1
+   audio_support[1]=FR3
+   audio_support[2]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=0
+   codec->efr=0
+   codec->amr=1
+ * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
+
+Determining channel mode and rate:
+ * MS: speech codec list (1 items):
+   codec[0]->type=FR1
+ * MSC: channel type permitted speech (2 items):
+   perm_spch[0]=FR1
+   perm_spch[1]=HR1
+ * BSS: audio support settings (3 items):
+   audio_support[0]=FR1
+   audio_support[1]=FR3
+   audio_support[2]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=0
+   codec->efr=1
+   codec->amr=0
+ * result: rc=0, full_rate=1, chan_mode=SPEECH_V1
+
+Determining channel mode and rate:
+ * MS: speech codec list (1 items):
+   codec[0]->type=HR1
+ * MSC: channel type permitted speech (2 items):
+   perm_spch[0]=FR1
+   perm_spch[1]=HR1
+ * BSS: audio support settings (3 items):
+   audio_support[0]=FR1
+   audio_support[1]=FR2
+   audio_support[2]=HR1
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=0
+   codec->amr=0
  * result: rc=0, full_rate=0, chan_mode=SPEECH_V1
 
 ============== test_selected_non_working ==============
@@ -679,6 +927,11 @@
    audio_support[0]=FR1
    audio_support[1]=FR3
    audio_support[2]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=-1, full_rate=-1, chan_mode=SIGNALLING
 
 Determining channel mode and rate:
@@ -691,6 +944,11 @@
    audio_support[0]=FR1
    audio_support[1]=FR3
    audio_support[2]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
  * result: rc=-1, full_rate=-1, chan_mode=SIGNALLING
 
 Determining channel mode and rate:
@@ -702,6 +960,62 @@
    audio_support[0]=FR1
    audio_support[1]=FR2
    audio_support[2]=HR1
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
+ * result: rc=-1, full_rate=-1, chan_mode=SIGNALLING
+
+Determining channel mode and rate:
+ * MS: speech codec list (1 items):
+   codec[0]->type=HR1
+ * MSC: channel type permitted speech (1 items):
+   perm_spch[0]=FR2
+ * BSS: audio support settings (3 items):
+   audio_support[0]=FR1
+   audio_support[1]=FR3
+   audio_support[2]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
+ * result: rc=-1, full_rate=-1, chan_mode=SIGNALLING
+
+Determining channel mode and rate:
+ * MS: speech codec list (1 items):
+   codec[0]->type=HR1
+ * MSC: channel type permitted speech (2 items):
+   perm_spch[0]=FR1
+   perm_spch[1]=HR1
+ * BSS: audio support settings (1 items):
+   audio_support[0]=HR3
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=1
+   codec->efr=1
+   codec->amr=1
+ * result: rc=-1, full_rate=-1, chan_mode=SIGNALLING
+
+Determining channel mode and rate:
+ * MS: speech codec list (5 items):
+   codec[0]->type=FR1
+   codec[1]->type=FR2
+   codec[2]->type=FR3
+   codec[3]->type=HR1
+   codec[4]->type=HR3
+ * MSC: channel type permitted speech (1 items):
+   perm_spch[0]=HR3
+ * BSS: audio support settings (3 items):
+   audio_support[0]=FR1
+   audio_support[1]=FR2
+   audio_support[2]=HR1
+ * BTS: audio support settings:
+   (GSM-FR implicitly supported)
+   codec->hr=0
+   codec->efr=0
+   codec->amr=1
  * result: rc=-1, full_rate=-1, chan_mode=SIGNALLING
 
 Testing execution completed.
