tests: Bluetooth: CAP: Refactor unittests to use discover

Instead of declaring the endpoints in the unit tests, we
not define them in the mock unicast client and use the
discover function to get pointers.

This allows for a proper implementation of
bt_bap_unicast_client_has_ep as well as makes the tests more similar
to a normal application.

Signed-off-by: Emil Gydesen <[email protected]>

Author: Thalley

tests/bluetooth/audio/cap_initiator/include/test_common.h

@@ -1,10 +1,11 @@
 /* test_common.h */
 
 /*
- * Copyright (c) 2024 Nordic Semiconductor ASA
+ * Copyright (c) 2024-2025 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */
+#include <stdint.h>
 
 #include <zephyr/bluetooth/audio/bap.h>
 #include <zephyr/bluetooth/audio/bap_lc3_preset.h>
@@ -14,7 +15,7 @@
 void test_mocks_init(void);
 void test_mocks_cleanup(void);
 
-void test_conn_init(struct bt_conn *conn);
+void test_conn_init(struct bt_conn *conn, uint8_t index);
 
 void test_unicast_set_state(struct bt_cap_stream *cap_stream, struct bt_conn *conn,
 			    struct bt_bap_ep *ep, struct bt_bap_lc3_preset *preset,

tests/bluetooth/audio/cap_initiator/src/main.c

@@ -43,7 +43,7 @@ struct cap_initiator_test_suite_fixture {
 static void cap_initiator_test_suite_fixture_init(struct cap_initiator_test_suite_fixture *fixture)
 {
 	for (size_t i = 0; i < ARRAY_SIZE(fixture->conns); i++) {
-		test_conn_init(&fixture->conns[i]);
+		test_conn_init(&fixture->conns[i], i);
 	}
 }
 

tests/bluetooth/audio/cap_initiator/src/test_common.c

@@ -1,11 +1,13 @@
 /* test_common.c - common procedures for unit test of CAP initiator */
 
 /*
- * Copyright (c) 2024 Nordic Semiconductor ASA
+ * Copyright (c) 2024-2025 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include <stdint.h>
+
 #include <zephyr/bluetooth/audio/bap.h>
 #include <zephyr/bluetooth/audio/bap_lc3_preset.h>
 #include <zephyr/bluetooth/audio/cap.h>
@@ -32,9 +34,9 @@ void test_mocks_cleanup(void)
 	mock_cap_initiator_cleanup();
 }
 
-void test_conn_init(struct bt_conn *conn)
+void test_conn_init(struct bt_conn *conn, uint8_t index)
 {
-	conn->index = 0;
+	conn->index = index;
 	conn->info.type = BT_CONN_TYPE_LE;
 	conn->info.role = BT_CONN_ROLE_CENTRAL;
 	conn->info.state = BT_CONN_STATE_CONNECTED;

tests/bluetooth/audio/cap_initiator/src/test_unicast_start.c

@@ -36,9 +36,22 @@
 #include "ztest_assert.h"
 #include "ztest_test.h"
 
+BUILD_ASSERT(CONFIG_BT_MAX_CONN *(CONFIG_BT_BAP_UNICAST_CLIENT_ASE_SNK_COUNT +
+				  CONFIG_BT_BAP_UNICAST_CLIENT_ASE_SRC_COUNT) >=
+	     CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT);
+
+/* Either BT_AUDIO_DIR_SINK or BT_AUDIO_DIR_SOURCE */
+#define INDEX_TO_DIR(_idx) (((_idx) & 1U) + 1U)
+
+DECLARE_FAKE_VOID_FUNC(mock_bap_discover_endpoint, struct bt_conn *, enum bt_audio_dir,
+		       struct bt_bap_ep *);
+DEFINE_FAKE_VOID_FUNC(mock_bap_discover_endpoint, struct bt_conn *, enum bt_audio_dir,
+		      struct bt_bap_ep *);
+
 struct cap_initiator_test_unicast_start_fixture {
 	struct bt_cap_stream cap_streams[CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT];
-	struct bt_bap_ep eps[CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT];
+	struct bt_bap_ep *snk_eps[CONFIG_BT_MAX_CONN][CONFIG_BT_BAP_UNICAST_CLIENT_ASE_SNK_COUNT];
+	struct bt_bap_ep *src_eps[CONFIG_BT_MAX_CONN][CONFIG_BT_BAP_UNICAST_CLIENT_ASE_SRC_COUNT];
 	struct bt_cap_unicast_audio_start_stream_param
 		audio_start_stream_params[CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT];
 	struct bt_cap_unicast_audio_start_param audio_start_param;
@@ -51,9 +64,9 @@ static void cap_initiator_test_unicast_start_fixture_init(
 	struct cap_initiator_test_unicast_start_fixture *fixture)
 {
 	struct bt_cap_unicast_group_stream_pair_param
-		pair_params[CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT] = {0};
+		group_pair_params[CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT] = {0};
 	struct bt_cap_unicast_group_stream_param
-		stream_params[CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT] = {0};
+		group_stream_param[CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT] = {0};
 	struct bt_cap_unicast_group_param group_param = {0};
 	size_t stream_cnt = 0U;
 	size_t pair_cnt = 0U;
@@ -63,24 +76,20 @@ static void cap_initiator_test_unicast_start_fixture_init(
 		BT_AUDIO_LOCATION_MONO_AUDIO, BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED);
 
 	for (size_t i = 0U; i < ARRAY_SIZE(fixture->conns); i++) {
-		test_conn_init(&fixture->conns[i]);
+		test_conn_init(&fixture->conns[i], i);
 	}
 
-	for (size_t i = 0U; i < ARRAY_SIZE(fixture->eps); i++) {
-		const uint8_t dir = (i & 1) + 1; /* Makes it either 1 or 2 (sink or source)*/
+	while (stream_cnt < ARRAY_SIZE(group_stream_param)) {
+		const enum bt_audio_dir dir = INDEX_TO_DIR(stream_cnt);
 
-		fixture->eps[i].dir = dir;
-	}
-
-	while (stream_cnt < ARRAY_SIZE(stream_params)) {
-		stream_params[stream_cnt].stream = &fixture->cap_streams[stream_cnt];
-		stream_params[stream_cnt].qos_cfg = &fixture->preset.qos;
+		group_stream_param[stream_cnt].stream = &fixture->cap_streams[stream_cnt];
+		group_stream_param[stream_cnt].qos_cfg = &fixture->preset.qos;
 
 		/* Switch between sink and source depending on index*/
-		if ((stream_cnt & 1) == 0) {
-			pair_params[pair_cnt].tx_param = &stream_params[stream_cnt];
+		if (dir == BT_AUDIO_DIR_SINK) {
+			group_pair_params[pair_cnt].tx_param = &group_stream_param[stream_cnt];
 		} else {
-			pair_params[pair_cnt].rx_param = &stream_params[stream_cnt];
+			group_pair_params[pair_cnt].rx_param = &group_stream_param[stream_cnt];
 		}
 
 		pair_cnt = DIV_ROUND_UP(stream_cnt, 2U);
@@ -89,42 +98,133 @@ static void cap_initiator_test_unicast_start_fixture_init(
 
 	group_param.packing = BT_ISO_PACKING_SEQUENTIAL;
 	group_param.params_count = pair_cnt;
-	group_param.params = pair_params;
+	group_param.params = group_pair_params;
 
 	err = bt_cap_unicast_group_create(&group_param, &fixture->unicast_group);
 	zassert_equal(err, 0, "Unexpected return value %d", err);
+}
+
+static void *cap_initiator_test_unicast_start_setup(void)
+{
+	struct cap_initiator_test_unicast_start_fixture *fixture;
+
+	fixture = malloc(sizeof(*fixture));
+	zassert_not_null(fixture);
+
+	return fixture;
+}
+
+static void mock_discover(struct cap_initiator_test_unicast_start_fixture *fixture)
+{
+	struct bt_bap_unicast_client_cb unicast_client_cb = {
+		.endpoint = mock_bap_discover_endpoint,
+	};
+	int err;
+
+	err = bt_bap_unicast_client_register_cb(&unicast_client_cb);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	for (size_t i = 0U; i < ARRAY_SIZE(fixture->conns); i++) {
+		RESET_FAKE(mock_bap_discover_endpoint);
+		err = bt_bap_unicast_client_discover(&fixture->conns[i], BT_AUDIO_DIR_SINK);
+		zassert_equal(0, err, "Unexpected return value %d", err);
+
+		/* TODO: use callback to populate eps */
+
+		zexpect_call_count("unicast_client_cb.bap_discover_endpoint",
+				   CONFIG_BT_BAP_UNICAST_CLIENT_ASE_SNK_COUNT,
+				   mock_bap_discover_endpoint_fake.call_count);
+		for (size_t j = 0U; j < mock_bap_discover_endpoint_fake.call_count; j++) {
+			/* Verify conn */
+			zassert_equal(mock_bap_discover_endpoint_fake.arg0_history[j],
+				      &fixture->conns[i], "%p",
+				      mock_bap_discover_endpoint_fake.arg0_history[j]);
+
+			/* Verify dir */
+			zassert_equal(mock_bap_discover_endpoint_fake.arg1_history[j],
+				      BT_AUDIO_DIR_SINK, "%d",
+				      mock_bap_discover_endpoint_fake.arg1_history[j]);
+
+			/* Verify and store ep */
+			zassert_not_equal(mock_bap_discover_endpoint_fake.arg2_history[j], NULL,
+					  "%p", mock_bap_discover_endpoint_fake.arg2_history[j]);
+
+			fixture->snk_eps[fixture->conns[i].index][j] =
+				mock_bap_discover_endpoint_fake.arg2_history[j];
+		}
 
+		RESET_FAKE(mock_bap_discover_endpoint);
+		err = bt_bap_unicast_client_discover(&fixture->conns[i], BT_AUDIO_DIR_SOURCE);
+		zassert_equal(0, err, "Unexpected return value %d", err);
+
+		zexpect_call_count("unicast_client_cb.bap_discover_endpoint",
+				   CONFIG_BT_BAP_UNICAST_CLIENT_ASE_SRC_COUNT,
+				   mock_bap_discover_endpoint_fake.call_count);
+		for (size_t j = 0U; j < mock_bap_discover_endpoint_fake.call_count; j++) {
+			/* Verify conn */
+			zassert_equal(mock_bap_discover_endpoint_fake.arg0_history[j],
+				      &fixture->conns[i], "%p",
+				      mock_bap_discover_endpoint_fake.arg0_history[j]);
+
+			/* Verify dir */
+			zassert_equal(mock_bap_discover_endpoint_fake.arg1_history[j],
+				      BT_AUDIO_DIR_SOURCE, "%d",
+				      mock_bap_discover_endpoint_fake.arg1_history[j]);
+
+			/* Verify and store ep */
+			zassert_not_equal(mock_bap_discover_endpoint_fake.arg2_history[j], NULL,
+					  "%p", mock_bap_discover_endpoint_fake.arg2_history[j]);
+
+			fixture->src_eps[fixture->conns[i].index][j] =
+				mock_bap_discover_endpoint_fake.arg2_history[j];
+		}
+	}
+
+	/* We don't need the callbacks anymore */
+	err = bt_bap_unicast_client_unregister_cb(&unicast_client_cb);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+}
+
+static void init_default_params(struct cap_initiator_test_unicast_start_fixture *fixture)
+{
 	/* Setup default params */
 	ARRAY_FOR_EACH(fixture->audio_start_stream_params, i) {
 		struct bt_cap_unicast_audio_start_stream_param *stream_param =
 			&fixture->audio_start_stream_params[i];
+
 		/* We pair 2 streams, so only increase conn_index every 2nd stream and otherwise
 		 * round robin on all conns
 		 */
-		const size_t conn_index = (i / 2) % ARRAY_SIZE(fixture->conns);
+		const size_t conn_index = (i / 2U) % ARRAY_SIZE(fixture->conns);
+		const size_t ep_index = i / (ARRAY_SIZE(fixture->conns) * 2U);
+		const enum bt_audio_dir dir = INDEX_TO_DIR(i);
 
 		stream_param->stream = &fixture->cap_streams[i];
 		stream_param->codec_cfg = &fixture->preset.codec_cfg;
-		/* Distribute the streams equally among the connections */
+
+		/* Distribute the streams like
+		 * [0]: conn[0] src[0]
+		 * [1]: conn[0] snk[0]
+		 * [2]: conn[1] src[0]
+		 * [3]: conn[0] snk[0]
+		 * [4]: conn[0] src[1]
+		 * [5]: conn[0] snk[1]
+		 * [6]: conn[1] src[1]
+		 * [7]: conn[0] snk[1]
+		 */
 		stream_param->member.member = &fixture->conns[conn_index];
-		stream_param->ep = &fixture->eps[i];
+		if (dir == BT_AUDIO_DIR_SINK) {
+			stream_param->ep = fixture->snk_eps[conn_index][ep_index];
+		} else {
+			stream_param->ep = fixture->src_eps[conn_index][ep_index];
+		}
 	}
 
 	fixture->audio_start_param.type = BT_CAP_SET_TYPE_AD_HOC;
 	fixture->audio_start_param.count = CONFIG_BT_BAP_UNICAST_CLIENT_GROUP_STREAM_COUNT;
 	fixture->audio_start_param.stream_params = fixture->audio_start_stream_params;
 }
 
-static void *cap_initiator_test_unicast_start_setup(void)
-{
-	struct cap_initiator_test_unicast_start_fixture *fixture;
-
-	fixture = malloc(sizeof(*fixture));
-	zassert_not_null(fixture);
-
-	return fixture;
-}
-
 static void cap_initiator_test_unicast_start_before(void *f)
 {
 	struct cap_initiator_test_unicast_start_fixture *fixture = f;
@@ -135,6 +235,9 @@ static void cap_initiator_test_unicast_start_before(void *f)
 
 	err = bt_cap_initiator_register_cb(&mock_cap_initiator_cb);
 	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	mock_discover(fixture);
+	init_default_params(fixture);
 }
 
 static void cap_initiator_test_unicast_start_after(void *f)

tests/bluetooth/audio/cap_initiator/src/test_unicast_stop.c

@@ -47,7 +47,7 @@ static void cap_initiator_test_unicast_stop_fixture_init(
 		BT_AUDIO_LOCATION_MONO_AUDIO, BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED);
 
 	for (size_t i = 0U; i < ARRAY_SIZE(fixture->conns); i++) {
-		test_conn_init(&fixture->conns[i]);
+		test_conn_init(&fixture->conns[i], i);
 	}
 
 	for (size_t i = 0U; i < ARRAY_SIZE(fixture->eps); i++) {