1 /* test_ase_state_transition_invalid.c - ASE state transition tests */
2 
3 /*
4  * Copyright (c) 2023 Codecoup
5  * Copyright (c) 2024 Demant A/S
6  *
7  * SPDX-License-Identifier: Apache-2.0
8  */
9 
10 #include <stdint.h>
11 #include <stdlib.h>
12 #include <string.h>
13 
14 #include <zephyr/bluetooth/audio/lc3.h>
15 #include <zephyr/bluetooth/byteorder.h>
16 #include <zephyr/bluetooth/iso.h>
17 #include <zephyr/bluetooth/uuid.h>
18 #include <zephyr/kernel.h>
19 #include <zephyr/sys/slist.h>
20 #include <zephyr/sys/util.h>
21 #include <zephyr/types.h>
22 #include <zephyr/bluetooth/audio/audio.h>
23 #include <zephyr/bluetooth/audio/bap.h>
24 #include <zephyr/bluetooth/conn.h>
25 #include <zephyr/bluetooth/gatt.h>
26 #include <zephyr/sys/util_macro.h>
27 #include <zephyr/ztest_assert.h>
28 #include <zephyr/ztest_test.h>
29 #include <sys/types.h>
30 
31 #include "bap_unicast_server.h"
32 #include "bap_stream.h"
33 #include "conn.h"
34 #include "gatt_expects.h"
35 
36 #include "test_common.h"
37 
38 struct test_ase_state_transition_invalid_fixture {
39 	const struct bt_gatt_attr *ase_cp;
40 	const struct bt_gatt_attr *ase_snk;
41 	const struct bt_gatt_attr *ase_src;
42 	struct bt_bap_stream stream;
43 	struct bt_conn conn;
44 };
45 
test_ase_state_transition_invalid_setup(void)46 static void *test_ase_state_transition_invalid_setup(void)
47 {
48 	struct test_ase_state_transition_invalid_fixture *fixture;
49 
50 	fixture = malloc(sizeof(*fixture));
51 	zassert_not_null(fixture);
52 
53 
54 	return fixture;
55 }
56 
test_ase_state_transition_invalid_before(void * f)57 static void test_ase_state_transition_invalid_before(void *f)
58 {
59 	struct test_ase_state_transition_invalid_fixture *fixture =
60 		(struct test_ase_state_transition_invalid_fixture *)f;
61 	struct bt_bap_unicast_server_register_param param = {
62 		CONFIG_BT_ASCS_MAX_ASE_SNK_COUNT,
63 		CONFIG_BT_ASCS_MAX_ASE_SRC_COUNT
64 	};
65 	int err;
66 
67 	err = bt_bap_unicast_server_register(&param);
68 	zassert_equal(err, 0, "unexpected err response %d", err);
69 
70 	err = bt_bap_unicast_server_register_cb(&mock_bap_unicast_server_cb);
71 	zassert_equal(err, 0, "unexpected err response %d", err);
72 
73 	memset(fixture, 0, sizeof(struct test_ase_state_transition_invalid_fixture));
74 	fixture->ase_cp = test_ase_control_point_get();
75 	test_conn_init(&fixture->conn);
76 	test_ase_snk_get(CONFIG_BT_ASCS_MAX_ASE_SNK_COUNT, &fixture->ase_snk);
77 	test_ase_src_get(CONFIG_BT_ASCS_MAX_ASE_SRC_COUNT, &fixture->ase_src);
78 }
79 
test_ase_state_transition_invalid_after(void * f)80 static void test_ase_state_transition_invalid_after(void *f)
81 {
82 	int err;
83 
84 	err = bt_bap_unicast_server_unregister_cb(&mock_bap_unicast_server_cb);
85 	zassert_equal(err, 0, "unexpected err response %d", err);
86 
87 	/* Sleep to trigger any pending state changes from unregister_cb */
88 	k_sleep(K_SECONDS(1));
89 
90 	err = bt_bap_unicast_server_unregister();
91 	zassert_equal(err, 0, "Unexpected err response %d", err);
92 }
93 
test_ase_state_transition_invalid_teardown(void * f)94 static void test_ase_state_transition_invalid_teardown(void *f)
95 {
96 	free(f);
97 }
98 
99 ZTEST_SUITE(test_ase_state_transition_invalid, NULL, test_ase_state_transition_invalid_setup,
100 	    test_ase_state_transition_invalid_before, test_ase_state_transition_invalid_after,
101 	    test_ase_state_transition_invalid_teardown);
102 
test_client_config_codec_expect_transition_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)103 static void test_client_config_codec_expect_transition_error(struct bt_conn *conn, uint8_t ase_id,
104 							     const struct bt_gatt_attr *ase_cp)
105 {
106 	const uint8_t expected_error[] = {
107 		0x01,           /* Opcode = Config Codec */
108 		0x01,           /* Number_of_ASEs */
109 		ase_id,         /* ASE_ID[0] */
110 		0x04,           /* Response_Code[0] = Invalid ASE State Machine Transition */
111 		0x00,           /* Reason[0] */
112 	};
113 
114 	test_ase_control_client_config_codec(conn, ase_id, NULL);
115 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
116 					     sizeof(expected_error));
117 	test_mocks_reset();
118 }
119 
test_client_config_qos_expect_transition_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)120 static void test_client_config_qos_expect_transition_error(struct bt_conn *conn, uint8_t ase_id,
121 							   const struct bt_gatt_attr *ase_cp)
122 {
123 	const uint8_t expected_error[] = {
124 		0x02,           /* Opcode = Config QoS */
125 		0x01,           /* Number_of_ASEs */
126 		ase_id,         /* ASE_ID[0] */
127 		0x04,           /* Response_Code[0] = Invalid ASE State Machine Transition */
128 		0x00,           /* Reason[0] */
129 	};
130 
131 	test_ase_control_client_config_qos(conn, ase_id);
132 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
133 					     sizeof(expected_error));
134 	test_mocks_reset();
135 }
136 
test_client_enable_expect_transition_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)137 static void test_client_enable_expect_transition_error(struct bt_conn *conn, uint8_t ase_id,
138 						       const struct bt_gatt_attr *ase_cp)
139 {
140 	const uint8_t expected_error[] = {
141 		0x03,           /* Opcode = Enable */
142 		0x01,           /* Number_of_ASEs */
143 		ase_id,         /* ASE_ID[0] */
144 		0x04,           /* Response_Code[0] = Invalid ASE State Machine Transition */
145 		0x00,           /* Reason[0] */
146 	};
147 
148 	test_ase_control_client_enable(conn, ase_id);
149 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
150 					     sizeof(expected_error));
151 	test_mocks_reset();
152 }
153 
test_client_receiver_start_ready_expect_transition_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)154 static void test_client_receiver_start_ready_expect_transition_error(
155 	struct bt_conn *conn, uint8_t ase_id, const struct bt_gatt_attr *ase_cp)
156 {
157 	const uint8_t expected_error[] = {
158 		0x04,           /* Opcode = Receiver Start Ready */
159 		0x01,           /* Number_of_ASEs */
160 		ase_id,         /* ASE_ID[0] */
161 		0x04,           /* Response_Code[0] = Invalid ASE State Machine Transition */
162 		0x00,           /* Reason[0] */
163 	};
164 
165 	test_ase_control_client_receiver_start_ready(conn, ase_id);
166 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
167 					     sizeof(expected_error));
168 	test_mocks_reset();
169 }
170 
test_client_receiver_start_ready_expect_ase_direction_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)171 static void test_client_receiver_start_ready_expect_ase_direction_error(
172 	struct bt_conn *conn, uint8_t ase_id, const struct bt_gatt_attr *ase_cp)
173 {
174 	const uint8_t expected_error[] = {
175 		0x04,           /* Opcode = Receiver Start Ready */
176 		0x01,           /* Number_of_ASEs */
177 		ase_id,         /* ASE_ID[0] */
178 		0x05,           /* Response_Code[0] = Invalid ASE direction */
179 		0x00,           /* Reason[0] */
180 	};
181 
182 	test_ase_control_client_receiver_start_ready(conn, ase_id);
183 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
184 					     sizeof(expected_error));
185 	test_mocks_reset();
186 }
187 
test_client_disable_expect_transition_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)188 static void test_client_disable_expect_transition_error(struct bt_conn *conn, uint8_t ase_id,
189 							const struct bt_gatt_attr *ase_cp)
190 {
191 	const uint8_t expected_error[] = {
192 		0x05,           /* Opcode = Disable */
193 		0x01,           /* Number_of_ASEs */
194 		ase_id,         /* ASE_ID[0] */
195 		0x04,           /* Response_Code[0] = Invalid ASE State Machine Transition */
196 		0x00,           /* Reason[0] */
197 	};
198 
199 	test_ase_control_client_disable(conn, ase_id);
200 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
201 					     sizeof(expected_error));
202 	test_mocks_reset();
203 }
204 
test_client_receiver_stop_ready_expect_transition_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)205 static void test_client_receiver_stop_ready_expect_transition_error(
206 	struct bt_conn *conn, uint8_t ase_id, const struct bt_gatt_attr *ase_cp)
207 {
208 	const uint8_t expected_error[] = {
209 		0x06,           /* Opcode = Receiver Stop Ready */
210 		0x01,           /* Number_of_ASEs */
211 		ase_id,         /* ASE_ID[0] */
212 		0x04,           /* Response_Code[0] = Invalid ASE State Machine Transition */
213 		0x00,           /* Reason[0] */
214 	};
215 
216 	test_ase_control_client_receiver_stop_ready(conn, ase_id);
217 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
218 					     sizeof(expected_error));
219 	test_mocks_reset();
220 }
221 
test_client_receiver_stop_ready_expect_ase_direction_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)222 static void test_client_receiver_stop_ready_expect_ase_direction_error(
223 	struct bt_conn *conn, uint8_t ase_id, const struct bt_gatt_attr *ase_cp)
224 {
225 	const uint8_t expected_error[] = {
226 		0x06,           /* Opcode = Receiver Stop Ready */
227 		0x01,           /* Number_of_ASEs */
228 		ase_id,         /* ASE_ID[0] */
229 		0x05,           /* Response_Code[0] = Invalid ASE State Machine Transition */
230 		0x00,           /* Reason[0] */
231 	};
232 
233 	test_ase_control_client_receiver_stop_ready(conn, ase_id);
234 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
235 					     sizeof(expected_error));
236 	test_mocks_reset();
237 }
238 
test_client_update_metadata_expect_transition_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)239 static void test_client_update_metadata_expect_transition_error(
240 	struct bt_conn *conn, uint8_t ase_id, const struct bt_gatt_attr *ase_cp)
241 {
242 	const uint8_t expected_error[] = {
243 		0x07,           /* Opcode = Update Metadata */
244 		0x01,           /* Number_of_ASEs */
245 		ase_id,         /* ASE_ID[0] */
246 		0x04,           /* Response_Code[0] = Invalid ASE State Machine Transition */
247 		0x00,           /* Reason[0] */
248 	};
249 
250 	test_ase_control_client_update_metadata(conn, ase_id);
251 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
252 					     sizeof(expected_error));
253 	test_mocks_reset();
254 }
255 
test_client_release_expect_transition_error(struct bt_conn * conn,uint8_t ase_id,const struct bt_gatt_attr * ase_cp)256 static void test_client_release_expect_transition_error(struct bt_conn *conn, uint8_t ase_id,
257 							const struct bt_gatt_attr *ase_cp)
258 {
259 	const uint8_t expected_error[] = {
260 		0x08,           /* Opcode = Release */
261 		0x01,           /* Number_of_ASEs */
262 		ase_id,         /* ASE_ID[0] */
263 		0x04,           /* Response_Code[0] = Invalid ASE State Machine Transition */
264 		0x00,           /* Reason[0] */
265 	};
266 
267 	test_ase_control_client_release(conn, ase_id);
268 	expect_bt_gatt_notify_cb_called_once(conn, BT_UUID_ASCS_ASE_CP, ase_cp, expected_error,
269 					     sizeof(expected_error));
270 	test_mocks_reset();
271 }
272 
ZTEST_F(test_ase_state_transition_invalid,test_client_sink_state_idle)273 ZTEST_F(test_ase_state_transition_invalid, test_client_sink_state_idle)
274 {
275 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
276 	struct bt_conn *conn = &fixture->conn;
277 	uint8_t ase_id;
278 
279 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
280 
281 	ase_id = test_ase_id_get(fixture->ase_snk);
282 
283 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
284 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
285 	test_client_receiver_start_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
286 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
287 	test_client_receiver_stop_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
288 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
289 	test_client_release_expect_transition_error(conn, ase_id, ase_cp);
290 }
291 
ZTEST_F(test_ase_state_transition_invalid,test_client_sink_state_codec_configured)292 ZTEST_F(test_ase_state_transition_invalid, test_client_sink_state_codec_configured)
293 {
294 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
295 	struct bt_bap_stream *stream = &fixture->stream;
296 	struct bt_conn *conn = &fixture->conn;
297 	uint8_t ase_id;
298 
299 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
300 
301 	ase_id = test_ase_id_get(fixture->ase_snk);
302 	test_preamble_state_codec_configured(conn, ase_id, stream);
303 
304 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
305 	test_client_receiver_start_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
306 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
307 	test_client_receiver_stop_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
308 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
309 }
310 
ZTEST_F(test_ase_state_transition_invalid,test_client_sink_state_qos_configured)311 ZTEST_F(test_ase_state_transition_invalid, test_client_sink_state_qos_configured)
312 {
313 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
314 	struct bt_bap_stream *stream = &fixture->stream;
315 	struct bt_conn *conn = &fixture->conn;
316 	uint8_t ase_id;
317 
318 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
319 
320 	ase_id = test_ase_id_get(fixture->ase_snk);
321 	test_preamble_state_qos_configured(conn, ase_id, stream);
322 
323 	test_client_receiver_start_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
324 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
325 	test_client_receiver_stop_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
326 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
327 }
328 
ZTEST_F(test_ase_state_transition_invalid,test_client_sink_state_enabling)329 ZTEST_F(test_ase_state_transition_invalid, test_client_sink_state_enabling)
330 {
331 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
332 	struct bt_bap_stream *stream = &fixture->stream;
333 	struct bt_conn *conn = &fixture->conn;
334 	uint8_t ase_id;
335 
336 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
337 
338 	ase_id = test_ase_id_get(fixture->ase_snk);
339 	test_preamble_state_enabling(conn, ase_id, stream);
340 
341 	test_client_config_codec_expect_transition_error(conn, ase_id, ase_cp);
342 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
343 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
344 	test_client_receiver_start_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
345 	test_client_receiver_stop_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
346 }
347 
ZTEST_F(test_ase_state_transition_invalid,test_sink_client_state_streaming)348 ZTEST_F(test_ase_state_transition_invalid, test_sink_client_state_streaming)
349 {
350 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
351 	struct bt_bap_stream *stream = &fixture->stream;
352 	struct bt_conn *conn = &fixture->conn;
353 	struct bt_iso_chan *chan;
354 	uint8_t ase_id;
355 
356 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
357 
358 	ase_id = test_ase_id_get(fixture->ase_snk);
359 	test_preamble_state_streaming(conn, ase_id, stream, &chan, false);
360 
361 	test_client_config_codec_expect_transition_error(conn, ase_id, ase_cp);
362 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
363 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
364 	test_client_receiver_start_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
365 	test_client_receiver_stop_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
366 }
367 
expect_ase_state_releasing(struct bt_conn * conn,const struct bt_gatt_attr * ase)368 static void expect_ase_state_releasing(struct bt_conn *conn, const struct bt_gatt_attr *ase)
369 {
370 	struct test_ase_chrc_value_hdr hdr = { 0xff };
371 	ssize_t ret;
372 
373 	zexpect_not_null(conn);
374 	zexpect_not_null(ase);
375 
376 	ret = ase->read(conn, ase, &hdr, sizeof(hdr), 0);
377 	zassert_false(ret < 0, "attr->read returned unexpected (err 0x%02x)", BT_GATT_ERR(ret));
378 	zassert_equal(BT_BAP_EP_STATE_RELEASING, hdr.ase_state,
379 		      "unexpected ASE_State 0x%02x", hdr.ase_state);
380 }
381 
ZTEST_F(test_ase_state_transition_invalid,test_client_sink_state_releasing)382 ZTEST_F(test_ase_state_transition_invalid, test_client_sink_state_releasing)
383 {
384 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
385 	struct bt_bap_stream *stream = &fixture->stream;
386 	struct bt_conn *conn = &fixture->conn;
387 	struct bt_iso_chan *chan;
388 	uint8_t ase_id;
389 
390 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
391 
392 	ase_id = test_ase_id_get(fixture->ase_snk);
393 	test_preamble_state_releasing(conn, ase_id, stream, &chan, false);
394 	expect_ase_state_releasing(conn, fixture->ase_snk);
395 
396 	test_client_config_codec_expect_transition_error(conn, ase_id, ase_cp);
397 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
398 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
399 	test_client_receiver_start_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
400 	test_client_receiver_stop_ready_expect_ase_direction_error(conn, ase_id, ase_cp);
401 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
402 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
403 }
404 
ZTEST_F(test_ase_state_transition_invalid,test_client_source_state_idle)405 ZTEST_F(test_ase_state_transition_invalid, test_client_source_state_idle)
406 {
407 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
408 	struct bt_conn *conn = &fixture->conn;
409 	uint8_t ase_id;
410 
411 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
412 
413 	ase_id = test_ase_id_get(fixture->ase_src);
414 
415 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
416 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
417 	test_client_receiver_start_ready_expect_transition_error(conn, ase_id, ase_cp);
418 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
419 	test_client_receiver_stop_ready_expect_transition_error(conn, ase_id, ase_cp);
420 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
421 	test_client_release_expect_transition_error(conn, ase_id, ase_cp);
422 }
423 
ZTEST_F(test_ase_state_transition_invalid,test_client_source_state_codec_configured)424 ZTEST_F(test_ase_state_transition_invalid, test_client_source_state_codec_configured)
425 {
426 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
427 	struct bt_bap_stream *stream = &fixture->stream;
428 	struct bt_conn *conn = &fixture->conn;
429 	uint8_t ase_id;
430 
431 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
432 
433 	ase_id = test_ase_id_get(fixture->ase_src);
434 	test_preamble_state_codec_configured(conn, ase_id, stream);
435 
436 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
437 	test_client_receiver_start_ready_expect_transition_error(conn, ase_id, ase_cp);
438 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
439 	test_client_receiver_stop_ready_expect_transition_error(conn, ase_id, ase_cp);
440 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
441 }
442 
ZTEST_F(test_ase_state_transition_invalid,test_client_source_state_qos_configured)443 ZTEST_F(test_ase_state_transition_invalid, test_client_source_state_qos_configured)
444 {
445 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
446 	struct bt_bap_stream *stream = &fixture->stream;
447 	struct bt_conn *conn = &fixture->conn;
448 	uint8_t ase_id;
449 
450 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
451 
452 	ase_id = test_ase_id_get(fixture->ase_src);
453 	test_preamble_state_qos_configured(conn, ase_id, stream);
454 
455 	test_client_receiver_start_ready_expect_transition_error(conn, ase_id, ase_cp);
456 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
457 	test_client_receiver_stop_ready_expect_transition_error(conn, ase_id, ase_cp);
458 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
459 }
460 
ZTEST_F(test_ase_state_transition_invalid,test_client_source_state_enabling)461 ZTEST_F(test_ase_state_transition_invalid, test_client_source_state_enabling)
462 {
463 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
464 	struct bt_bap_stream *stream = &fixture->stream;
465 	struct bt_conn *conn = &fixture->conn;
466 	uint8_t ase_id;
467 
468 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
469 
470 	ase_id = test_ase_id_get(fixture->ase_src);
471 	test_preamble_state_enabling(conn, ase_id, stream);
472 
473 	test_client_config_codec_expect_transition_error(conn, ase_id, ase_cp);
474 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
475 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
476 	test_client_receiver_stop_ready_expect_transition_error(conn, ase_id, ase_cp);
477 }
478 
ZTEST_F(test_ase_state_transition_invalid,test_client_source_state_streaming)479 ZTEST_F(test_ase_state_transition_invalid, test_client_source_state_streaming)
480 {
481 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
482 	struct bt_bap_stream *stream = &fixture->stream;
483 	struct bt_conn *conn = &fixture->conn;
484 	struct bt_iso_chan *chan;
485 	uint8_t ase_id;
486 
487 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
488 
489 	ase_id = test_ase_id_get(fixture->ase_src);
490 	test_preamble_state_streaming(conn, ase_id, stream, &chan, true);
491 
492 	test_client_config_codec_expect_transition_error(conn, ase_id, ase_cp);
493 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
494 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
495 	test_client_receiver_start_ready_expect_transition_error(conn, ase_id, ase_cp);
496 	test_client_receiver_stop_ready_expect_transition_error(conn, ase_id, ase_cp);
497 }
498 
ZTEST_F(test_ase_state_transition_invalid,test_client_source_state_disabling)499 ZTEST_F(test_ase_state_transition_invalid, test_client_source_state_disabling)
500 {
501 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
502 	struct bt_bap_stream *stream = &fixture->stream;
503 	struct bt_conn *conn = &fixture->conn;
504 	struct bt_iso_chan *chan;
505 	uint8_t ase_id;
506 
507 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
508 
509 	ase_id = test_ase_id_get(fixture->ase_src);
510 	test_preamble_state_disabling(conn, ase_id, stream, &chan);
511 
512 	test_client_config_codec_expect_transition_error(conn, ase_id, ase_cp);
513 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
514 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
515 	test_client_receiver_start_ready_expect_transition_error(conn, ase_id, ase_cp);
516 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
517 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
518 }
519 
ZTEST_F(test_ase_state_transition_invalid,test_client_source_state_releasing)520 ZTEST_F(test_ase_state_transition_invalid, test_client_source_state_releasing)
521 {
522 	const struct bt_gatt_attr *ase_cp = fixture->ase_cp;
523 	struct bt_bap_stream *stream = &fixture->stream;
524 	struct bt_conn *conn = &fixture->conn;
525 	struct bt_iso_chan *chan;
526 	uint8_t ase_id;
527 
528 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
529 
530 	ase_id = test_ase_id_get(fixture->ase_src);
531 	test_preamble_state_releasing(conn, ase_id, stream, &chan, true);
532 	expect_ase_state_releasing(conn, fixture->ase_src);
533 
534 	test_client_config_codec_expect_transition_error(conn, ase_id, ase_cp);
535 	test_client_config_qos_expect_transition_error(conn, ase_id, ase_cp);
536 	test_client_enable_expect_transition_error(conn, ase_id, ase_cp);
537 	test_client_receiver_start_ready_expect_transition_error(conn, ase_id, ase_cp);
538 	test_client_receiver_stop_ready_expect_transition_error(conn, ase_id, ase_cp);
539 	test_client_disable_expect_transition_error(conn, ase_id, ase_cp);
540 	test_client_update_metadata_expect_transition_error(conn, ase_id, ase_cp);
541 }
542 
test_server_config_codec_expect_error(struct bt_bap_stream * stream)543 static void test_server_config_codec_expect_error(struct bt_bap_stream *stream)
544 {
545 	struct bt_audio_codec_cfg codec_cfg = BT_AUDIO_CODEC_LC3_CONFIG(
546 		BT_AUDIO_CODEC_CFG_FREQ_16KHZ, BT_AUDIO_CODEC_CFG_DURATION_10,
547 		BT_AUDIO_LOCATION_FRONT_LEFT, 40U, 1, BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED);
548 	int err;
549 
550 	err = bt_bap_stream_reconfig(stream, &codec_cfg);
551 	zassert_false(err == 0, "bt_bap_stream_reconfig unexpected success");
552 }
553 
test_server_receiver_start_ready_expect_error(struct bt_bap_stream * stream)554 static void test_server_receiver_start_ready_expect_error(struct bt_bap_stream *stream)
555 {
556 	int err;
557 
558 	err = bt_bap_stream_start(stream);
559 	zassert_false(err == 0, "bt_bap_stream_start unexpected success");
560 }
561 
test_server_disable_expect_error(struct bt_bap_stream * stream)562 static void test_server_disable_expect_error(struct bt_bap_stream *stream)
563 {
564 	int err;
565 
566 	err = bt_bap_stream_disable(stream);
567 	zassert_false(err == 0, "bt_bap_stream_disable unexpected success");
568 }
569 
570 #if defined(CONFIG_BT_BAP_UNICAST_CLIENT)
571 #include "bap_endpoint.h"
572 
test_server_config_qos_expect_error(struct bt_bap_stream * stream)573 static void test_server_config_qos_expect_error(struct bt_bap_stream *stream)
574 {
575 	struct bt_bap_unicast_group group;
576 	int err;
577 
578 	sys_slist_init(&group.streams);
579 	sys_slist_append(&group.streams, &stream->_node);
580 
581 	err = bt_bap_stream_qos(stream->conn, &group);
582 	zassert_false(err == 0, "bt_bap_stream_qos unexpected success");
583 }
584 
test_server_enable_expect_error(struct bt_bap_stream * stream)585 static void test_server_enable_expect_error(struct bt_bap_stream *stream)
586 {
587 	const uint8_t meta[] = {
588 		BT_AUDIO_CODEC_DATA(BT_AUDIO_METADATA_TYPE_STREAM_CONTEXT,
589 				    BT_BYTES_LIST_LE16(BT_AUDIO_CONTEXT_TYPE_RINGTONE)),
590 	};
591 	int err;
592 
593 	err = bt_bap_stream_enable(stream, meta, ARRAY_SIZE(meta));
594 	zassert_false(err == 0, "bt_bap_stream_enable unexpected success");
595 }
596 
test_server_receiver_stop_ready_expect_error(struct bt_bap_stream * stream)597 static void test_server_receiver_stop_ready_expect_error(struct bt_bap_stream *stream)
598 {
599 	int err;
600 
601 	err = bt_bap_stream_stop(stream);
602 	zassert_false(err == 0, "bt_bap_stream_stop unexpected success");
603 }
604 #else
605 #define test_server_config_qos_expect_error(...)
606 #define test_server_enable_expect_error(...)
607 #define test_server_receiver_stop_ready_expect_error(...)
608 #endif /* CONFIG_BT_BAP_UNICAST_CLIENT */
609 
test_server_update_metadata_expect_error(struct bt_bap_stream * stream)610 static void test_server_update_metadata_expect_error(struct bt_bap_stream *stream)
611 {
612 	const uint8_t meta[] = {
613 		BT_AUDIO_CODEC_DATA(BT_AUDIO_METADATA_TYPE_STREAM_CONTEXT,
614 				    BT_BYTES_LIST_LE16(BT_AUDIO_CONTEXT_TYPE_RINGTONE)),
615 	};
616 	int err;
617 
618 	err = bt_bap_stream_metadata(stream, meta, ARRAY_SIZE(meta));
619 	zassert_false(err == 0, "bt_bap_stream_metadata unexpected success");
620 }
621 
ZTEST_F(test_ase_state_transition_invalid,test_server_sink_state_codec_configured)622 ZTEST_F(test_ase_state_transition_invalid, test_server_sink_state_codec_configured)
623 {
624 	struct bt_bap_stream *stream = &fixture->stream;
625 	struct bt_conn *conn = &fixture->conn;
626 	uint8_t ase_id;
627 
628 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
629 
630 	ase_id = test_ase_id_get(fixture->ase_snk);
631 	test_preamble_state_codec_configured(conn, ase_id, stream);
632 
633 	test_server_config_qos_expect_error(stream);
634 	test_server_enable_expect_error(stream);
635 	test_server_receiver_start_ready_expect_error(stream);
636 	test_server_disable_expect_error(stream);
637 	test_server_receiver_stop_ready_expect_error(stream);
638 	test_server_update_metadata_expect_error(stream);
639 }
640 
ZTEST_F(test_ase_state_transition_invalid,test_server_sink_state_qos_configured)641 ZTEST_F(test_ase_state_transition_invalid, test_server_sink_state_qos_configured)
642 {
643 	struct bt_bap_stream *stream = &fixture->stream;
644 	struct bt_conn *conn = &fixture->conn;
645 	uint8_t ase_id;
646 
647 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
648 
649 	ase_id = test_ase_id_get(fixture->ase_snk);
650 	test_preamble_state_qos_configured(conn, ase_id, stream);
651 
652 	test_server_config_qos_expect_error(stream);
653 	test_server_enable_expect_error(stream);
654 	test_server_receiver_start_ready_expect_error(stream);
655 	test_server_disable_expect_error(stream);
656 	test_server_receiver_stop_ready_expect_error(stream);
657 	test_server_update_metadata_expect_error(stream);
658 }
659 
ZTEST_F(test_ase_state_transition_invalid,test_server_sink_state_enabling)660 ZTEST_F(test_ase_state_transition_invalid, test_server_sink_state_enabling)
661 {
662 	struct bt_bap_stream *stream = &fixture->stream;
663 	struct bt_conn *conn = &fixture->conn;
664 	uint8_t ase_id;
665 
666 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
667 
668 	ase_id = test_ase_id_get(fixture->ase_snk);
669 	test_preamble_state_enabling(conn, ase_id, stream);
670 
671 	test_server_config_codec_expect_error(stream);
672 	test_server_config_qos_expect_error(stream);
673 	test_server_enable_expect_error(stream);
674 	test_server_receiver_stop_ready_expect_error(stream);
675 }
676 
ZTEST_F(test_ase_state_transition_invalid,test_server_sink_state_streaming)677 ZTEST_F(test_ase_state_transition_invalid, test_server_sink_state_streaming)
678 {
679 	struct bt_bap_stream *stream = &fixture->stream;
680 	struct bt_conn *conn = &fixture->conn;
681 	struct bt_iso_chan *chan;
682 	uint8_t ase_id;
683 
684 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
685 
686 	ase_id = test_ase_id_get(fixture->ase_snk);
687 	test_preamble_state_streaming(conn, ase_id, stream, &chan, false);
688 
689 	test_server_config_codec_expect_error(stream);
690 	test_server_config_qos_expect_error(stream);
691 	test_server_enable_expect_error(stream);
692 	test_server_receiver_start_ready_expect_error(stream);
693 	test_server_receiver_stop_ready_expect_error(stream);
694 }
695 
ZTEST_F(test_ase_state_transition_invalid,test_server_sink_state_releasing)696 ZTEST_F(test_ase_state_transition_invalid, test_server_sink_state_releasing)
697 {
698 	struct bt_bap_stream *stream = &fixture->stream;
699 	struct bt_conn *conn = &fixture->conn;
700 	struct bt_iso_chan *chan;
701 	uint8_t ase_id;
702 
703 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SNK);
704 
705 	ase_id = test_ase_id_get(fixture->ase_snk);
706 	test_preamble_state_releasing(conn, ase_id, stream, &chan, false);
707 	expect_ase_state_releasing(conn, fixture->ase_snk);
708 
709 	test_server_config_codec_expect_error(stream);
710 	test_server_config_qos_expect_error(stream);
711 	test_server_enable_expect_error(stream);
712 	test_server_receiver_start_ready_expect_error(stream);
713 	test_server_disable_expect_error(stream);
714 	test_server_receiver_stop_ready_expect_error(stream);
715 	test_server_update_metadata_expect_error(stream);
716 }
717 
ZTEST_F(test_ase_state_transition_invalid,test_server_source_state_codec_configured)718 ZTEST_F(test_ase_state_transition_invalid, test_server_source_state_codec_configured)
719 {
720 	struct bt_bap_stream *stream = &fixture->stream;
721 	struct bt_conn *conn = &fixture->conn;
722 	uint8_t ase_id;
723 
724 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
725 
726 	ase_id = test_ase_id_get(fixture->ase_src);
727 	test_preamble_state_codec_configured(conn, ase_id, stream);
728 
729 	test_server_config_qos_expect_error(stream);
730 	test_server_enable_expect_error(stream);
731 	test_server_receiver_start_ready_expect_error(stream);
732 	test_server_disable_expect_error(stream);
733 	test_server_receiver_stop_ready_expect_error(stream);
734 	test_server_update_metadata_expect_error(stream);
735 }
736 
ZTEST_F(test_ase_state_transition_invalid,test_server_source_state_qos_configured)737 ZTEST_F(test_ase_state_transition_invalid, test_server_source_state_qos_configured)
738 {
739 	struct bt_bap_stream *stream = &fixture->stream;
740 	struct bt_conn *conn = &fixture->conn;
741 	uint8_t ase_id;
742 
743 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
744 
745 	ase_id = test_ase_id_get(fixture->ase_src);
746 	test_preamble_state_qos_configured(conn, ase_id, stream);
747 
748 	test_server_config_qos_expect_error(stream);
749 	test_server_enable_expect_error(stream);
750 	test_server_receiver_start_ready_expect_error(stream);
751 	test_server_disable_expect_error(stream);
752 	test_server_receiver_stop_ready_expect_error(stream);
753 	test_server_update_metadata_expect_error(stream);
754 }
755 
ZTEST_F(test_ase_state_transition_invalid,test_server_source_state_enabling)756 ZTEST_F(test_ase_state_transition_invalid, test_server_source_state_enabling)
757 {
758 	struct bt_bap_stream *stream = &fixture->stream;
759 	struct bt_conn *conn = &fixture->conn;
760 	uint8_t ase_id;
761 
762 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
763 
764 	ase_id = test_ase_id_get(fixture->ase_src);
765 	test_preamble_state_enabling(conn, ase_id, stream);
766 
767 	test_server_config_codec_expect_error(stream);
768 	test_server_config_qos_expect_error(stream);
769 	test_server_enable_expect_error(stream);
770 	test_server_receiver_stop_ready_expect_error(stream);
771 }
772 
ZTEST_F(test_ase_state_transition_invalid,test_server_source_state_streaming)773 ZTEST_F(test_ase_state_transition_invalid, test_server_source_state_streaming)
774 {
775 	struct bt_bap_stream *stream = &fixture->stream;
776 	struct bt_conn *conn = &fixture->conn;
777 	struct bt_iso_chan *chan;
778 	uint8_t ase_id;
779 
780 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
781 
782 	ase_id = test_ase_id_get(fixture->ase_src);
783 	test_preamble_state_streaming(conn, ase_id, stream, &chan, true);
784 
785 	test_server_config_codec_expect_error(stream);
786 	test_server_config_qos_expect_error(stream);
787 	test_server_enable_expect_error(stream);
788 	test_server_receiver_start_ready_expect_error(stream);
789 	test_server_receiver_stop_ready_expect_error(stream);
790 }
791 
ZTEST_F(test_ase_state_transition_invalid,test_server_source_state_disabling)792 ZTEST_F(test_ase_state_transition_invalid, test_server_source_state_disabling)
793 {
794 	struct bt_bap_stream *stream = &fixture->stream;
795 	struct bt_conn *conn = &fixture->conn;
796 	struct bt_iso_chan *chan;
797 	uint8_t ase_id;
798 
799 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
800 
801 	ase_id = test_ase_id_get(fixture->ase_src);
802 	test_preamble_state_disabling(conn, ase_id, stream, &chan);
803 
804 	test_server_config_codec_expect_error(stream);
805 	test_server_config_qos_expect_error(stream);
806 	test_server_enable_expect_error(stream);
807 	test_server_receiver_start_ready_expect_error(stream);
808 	test_server_disable_expect_error(stream);
809 	test_server_receiver_stop_ready_expect_error(stream);
810 	test_server_update_metadata_expect_error(stream);
811 }
812 
ZTEST_F(test_ase_state_transition_invalid,test_server_source_state_releasing)813 ZTEST_F(test_ase_state_transition_invalid, test_server_source_state_releasing)
814 {
815 	struct bt_bap_stream *stream = &fixture->stream;
816 	struct bt_conn *conn = &fixture->conn;
817 	struct bt_iso_chan *chan;
818 	uint8_t ase_id;
819 
820 	Z_TEST_SKIP_IFNDEF(CONFIG_BT_ASCS_ASE_SRC);
821 
822 	ase_id = test_ase_id_get(fixture->ase_src);
823 	test_preamble_state_releasing(conn, ase_id, stream, &chan, true);
824 	expect_ase_state_releasing(conn, fixture->ase_src);
825 
826 	test_server_config_codec_expect_error(stream);
827 	test_server_config_qos_expect_error(stream);
828 	test_server_enable_expect_error(stream);
829 	test_server_receiver_start_ready_expect_error(stream);
830 	test_server_disable_expect_error(stream);
831 	test_server_receiver_stop_ready_expect_error(stream);
832 	test_server_update_metadata_expect_error(stream);
833 }
834