tests/bsim/bluetooth/audio/src/has_client_test.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2022 Codecoup
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/bluetooth/audio/has.h>

 #include "../../subsys/bluetooth/audio/has_internal.h"

 #include "common.h"

 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(has_client_test, LOG_LEVEL_DBG);

 extern enum bst_result_t bst_result;

 extern const char *test_preset_name_1;
 extern const char *test_preset_name_5;
 extern const uint8_t test_preset_index_1;
 extern const uint8_t test_preset_index_3;
 extern const uint8_t test_preset_index_5;
 extern const enum bt_has_properties test_preset_properties;

 CREATE_FLAG(g_service_discovered);
 CREATE_FLAG(g_preset_switched);
 CREATE_FLAG(g_preset_1_found);
 CREATE_FLAG(g_preset_3_found);
 CREATE_FLAG(g_preset_5_found);

 static struct bt_has *g_has;
 static uint8_t g_active_index;

 static void discover_cb(struct bt_conn *conn, int err, struct bt_has *has,
 			enum bt_has_hearing_aid_type type, enum bt_has_capabilities caps)
 {
 	if (err) {
 		FAIL("Failed to discover HAS (err %d)\n", err);
 		return;
 	}

 	LOG_DBG("HAS discovered type %d caps %d", type, caps);

 	g_has = has;
 	SET_FLAG(g_service_discovered);
 }

 static void preset_switch_cb(struct bt_has *has, int err, uint8_t index)
 {
 	if (err != 0) {
 		return;
 	}

 	LOG_DBG("Active preset index %d", index);

 	SET_FLAG(g_preset_switched);
 	g_active_index = index;
 }

 static void check_preset_record(const struct bt_has_preset_record *record,
 				enum bt_has_properties expected_properties,
 				const char *expected_name)
 {
 	if (record->properties != expected_properties || strcmp(record->name, expected_name)) {
 		FAIL("mismatch 0x%02x %s vs 0x%02x %s expected\n",
 		     record->properties, record->name, expected_properties, expected_name);
 	}
 }

 static void preset_read_rsp_cb(struct bt_has *has, int err,
 			       const struct bt_has_preset_record *record, bool is_last)
 {
 	if (err) {
 		FAIL("%s: err %d\n", __func__, err);
 		return;
 	}

 	if (record->index == test_preset_index_1) {
 		SET_FLAG(g_preset_1_found);

 		check_preset_record(record, test_preset_properties, test_preset_name_1);
 	} else if (record->index == test_preset_index_5) {
 		SET_FLAG(g_preset_5_found);

 		check_preset_record(record, test_preset_properties, test_preset_name_5);
 	} else {
 		FAIL("unexpected index 0x%02x", record->index);
 	}
 }

 static void preset_update_cb(struct bt_has *has, uint8_t index_prev,
 			     const struct bt_has_preset_record *record, bool is_last)
 {
 	if (record->index == test_preset_index_1) {
 		SET_FLAG(g_preset_1_found);
 	} else if (record->index == test_preset_index_3) {
 		SET_FLAG(g_preset_3_found);
 	} else if (record->index == test_preset_index_5) {
 		SET_FLAG(g_preset_5_found);
 	}
 }

 static const struct bt_has_client_cb has_cb = {
 	.discover = discover_cb,
 	.preset_switch = preset_switch_cb,
 	.preset_read_rsp = preset_read_rsp_cb,
 	.preset_update = preset_update_cb,
 };

 static bool test_preset_switch(uint8_t index)
 {
 	int err;

 	UNSET_FLAG(g_preset_switched);

 	err = bt_has_client_preset_set(g_has, index, false);
 	if (err < 0) {
 		LOG_DBG("%s (err %d)", __func__, err);
 		return false;
 	}

 	WAIT_FOR_COND(g_preset_switched);

 	return g_active_index == index;
 }

 static bool test_preset_next(uint8_t active_index_expected)
 {
 	int err;

 	UNSET_FLAG(g_preset_switched);

 	err = bt_has_client_preset_next(g_has, false);
 	if (err < 0) {
 		LOG_DBG("%s (err %d)", __func__, err);
 		return false;
 	}

 	WAIT_FOR_COND(g_preset_switched);

 	return g_active_index == active_index_expected;
 }

 static bool test_preset_prev(uint8_t active_index_expected)
 {
 	int err;

 	UNSET_FLAG(g_preset_switched);

 	err = bt_has_client_preset_prev(g_has, false);
 	if (err < 0) {
 		LOG_DBG("%s (err %d)", __func__, err);
 		return false;
 	}

 	WAIT_FOR_COND(g_preset_switched);

 	return g_active_index == active_index_expected;
 }

 static void discover_has(void)
 {
 	int err;

 	g_service_discovered = false;

 	err = bt_has_client_discover(default_conn);
 	if (err < 0) {
 		FAIL("Failed to discover HAS (err %d)\n", err);
 		return;
 	}

 	WAIT_FOR_COND(g_service_discovered);
 }

 static void test_main(void)
 {
 	int err;

 	err = bt_enable(NULL);
 	if (err < 0) {
 		FAIL("Bluetooth discover failed (err %d)\n", err);
 		return;
 	}

 	LOG_DBG("Bluetooth initialized");

 	err = bt_has_client_cb_register(&has_cb);
 	if (err < 0) {
 		FAIL("Failed to register callbacks (err %d)\n", err);
 		return;
 	}

 	bt_le_scan_cb_register(&common_scan_cb);

 	err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, NULL);
 	if (err < 0) {
 		FAIL("Scanning failed to start (err %d)\n", err);
 		return;
 	}

 	LOG_DBG("Scanning successfully started");

 	WAIT_FOR_FLAG(flag_connected);

 	discover_has();
 	WAIT_FOR_COND(g_preset_switched);

 	err = bt_has_client_presets_read(g_has, BT_HAS_PRESET_INDEX_FIRST, 255);
 	if (err < 0) {
 		FAIL("Failed to read presets (err %d)\n", err);
 		return;
 	}

 	WAIT_FOR_COND(g_preset_1_found);
 	WAIT_FOR_COND(g_preset_5_found);

 	if (!test_preset_switch(test_preset_index_1)) {
 		FAIL("Failed to switch preset %d\n", test_preset_index_1);
 		return;
 	}

 	if (!test_preset_switch(test_preset_index_5)) {
 		FAIL("Failed to switch preset %d\n", test_preset_index_5);
 		return;
 	}

 	if (!test_preset_next(test_preset_index_1)) {
 		FAIL("Failed to set next preset %d\n", test_preset_index_1);
 		return;
 	}

 	if (!test_preset_next(test_preset_index_5)) {
 		FAIL("Failed to set next preset %d\n", test_preset_index_5);
 		return;
 	}

 	if (!test_preset_next(test_preset_index_1)) {
 		FAIL("Failed to set next preset %d\n", test_preset_index_1);
 		return;
 	}

 	if (!test_preset_prev(test_preset_index_5)) {
 		FAIL("Failed to set previous preset %d\n", test_preset_index_5);
 		return;
 	}

 	if (!test_preset_prev(test_preset_index_1)) {
 		FAIL("Failed to set previous preset %d\n", test_preset_index_1);
 		return;
 	}

 	if (!test_preset_prev(test_preset_index_5)) {
 		FAIL("Failed to set previous preset %d\n", test_preset_index_5);
 		return;
 	}

 	PASS("HAS main PASS\n");
 }

 #define FEATURES_SUB_NTF        BIT(0)
 #define ACTIVE_INDEX_SUB_NTF    BIT(1)
 #define PRESET_CHANGED_SUB_NTF  BIT(2)
 #define SUB_NTF_ALL		(FEATURES_SUB_NTF | ACTIVE_INDEX_SUB_NTF | PRESET_CHANGED_SUB_NTF)

 CREATE_FLAG(flag_features_discovered);
 CREATE_FLAG(flag_active_preset_index_discovered);
 CREATE_FLAG(flag_control_point_discovered);
 CREATE_FLAG(flag_all_notifications_received);

 enum preset_state {
 	STATE_UNKNOWN,
 	STATE_AVAILABLE,
 	STATE_UNAVAILABLE,
 	STATE_DELETED,
 };

 static enum preset_state preset_state_1;
 static enum preset_state preset_state_3;
 static enum preset_state preset_state_5;

 static struct bt_uuid_16 uuid = BT_UUID_INIT_16(0);
 static struct bt_gatt_discover_params discover_params;
 static struct bt_gatt_subscribe_params features_sub;
 static struct bt_gatt_subscribe_params active_preset_index_sub;
 static struct bt_gatt_subscribe_params control_point_sub;
 static uint8_t notify_received_mask;

 static void preset_availability_changed(uint8_t index, bool available)
 {
 	enum preset_state state = available ? STATE_AVAILABLE : STATE_UNAVAILABLE;

 	if (index == test_preset_index_1) {
 		preset_state_1 = state;
 	} else if (index == test_preset_index_3) {
 		preset_state_3 = state;
 	} else if (index == test_preset_index_5) {
 		preset_state_5 = state;
 	} else {
 		FAIL("invalid preset index 0x%02x", index);
 	}
 }

 static uint8_t notify_handler(struct bt_conn *conn, struct bt_gatt_subscribe_params *params,
 			      const void *data, uint16_t length)
 {
 	LOG_DBG("conn %p params %p data %p length %u", (void *)conn, params, data, length);

 	if (params == &features_sub) {
 		if (data == NULL) {
 			LOG_DBG("features_sub [UNSUBSCRIBED]");
 			return BT_GATT_ITER_STOP;
 		}

 		LOG_DBG("Received features_sub notification");
 		notify_received_mask |= FEATURES_SUB_NTF;
 	} else if (params == &active_preset_index_sub) {
 		if (data == NULL) {
 			LOG_DBG("active_preset_index_sub_sub [UNSUBSCRIBED]");
 			return BT_GATT_ITER_STOP;
 		}

 		LOG_DBG("Received active_preset_index_sub_sub notification");
 		notify_received_mask |= ACTIVE_INDEX_SUB_NTF;
 	} else if (params == &control_point_sub) {
 		const struct bt_has_cp_hdr *hdr;

 		if (data == NULL) {
 			LOG_DBG("control_point_sub [UNSUBSCRIBED]");
 			return BT_GATT_ITER_STOP;
 		}

 		if (length < sizeof(*hdr)) {
 			FAIL("malformed bt_has_cp_hdr");
 			return BT_GATT_ITER_STOP;
 		}

 		hdr = data;

 		if (hdr->opcode == BT_HAS_OP_PRESET_CHANGED) {
 			const struct bt_has_cp_preset_changed *pc;

 			if (length < (sizeof(*hdr) + sizeof(*pc))) {
 				FAIL("malformed bt_has_cp_preset_changed");
 				return BT_GATT_ITER_STOP;
 			}

 			pc = (const void *)hdr->data;

 			switch (pc->change_id) {
 			case BT_HAS_CHANGE_ID_GENERIC_UPDATE: {
 				const struct bt_has_cp_generic_update *gu;
 				bool is_available;

 				if (length < (sizeof(*hdr) + sizeof(*pc) + sizeof(*gu))) {
 					FAIL("malformed bt_has_cp_generic_update");
 					return BT_GATT_ITER_STOP;
 				}

 				gu = (const void *)pc->additional_params;

 				LOG_DBG("Received generic update index 0x%02x props 0x%02x",
 					gu->index, gu->properties);

 				is_available = (gu->properties & BT_HAS_PROP_AVAILABLE) != 0;

 				preset_availability_changed(gu->index, is_available);
 				break;
 			}
 			default:
 				LOG_DBG("Unexpected Change ID 0x%02x", pc->change_id);
 				return BT_GATT_ITER_STOP;
 			}

 			if (pc->is_last) {
 				notify_received_mask |= PRESET_CHANGED_SUB_NTF;
 			}
 		} else {
 			LOG_DBG("Unexpected opcode 0x%02x", hdr->opcode);
 			return BT_GATT_ITER_STOP;
 		}
 	}

 	LOG_DBG("pacs_instance.notify_received_mask is %d", notify_received_mask);

 	if (notify_received_mask == SUB_NTF_ALL) {
 		SET_FLAG(flag_all_notifications_received);
 		notify_received_mask = 0;
 	}

 	return BT_GATT_ITER_CONTINUE;
 }

 static void subscribe_cb(struct bt_conn *conn, uint8_t err, struct bt_gatt_subscribe_params *params)
 {
 	if (err != BT_ATT_ERR_SUCCESS) {
 		return;
 	}

 	LOG_DBG("[SUBSCRIBED]");

 	if (params == &features_sub) {
 		SET_FLAG(flag_features_discovered);
 		return;
 	}

 	if (params == &control_point_sub) {
 		SET_FLAG(flag_control_point_discovered);
 		return;
 	}

 	if (params == &active_preset_index_sub) {
 		SET_FLAG(flag_active_preset_index_discovered);
 		return;
 	}
 }

 static uint8_t discover_features_cb(struct bt_conn *conn, const struct bt_gatt_attr *attr,
 				    struct bt_gatt_discover_params *params)
 {
 	struct bt_gatt_subscribe_params *subscribe_params;
 	int err;

 	if (!attr) {
 		LOG_DBG("Discover complete");
 		(void)memset(params, 0, sizeof(*params));
 		return BT_GATT_ITER_STOP;
 	}

 	if (!bt_uuid_cmp(params->uuid, BT_UUID_HAS_HEARING_AID_FEATURES)) {
 		LOG_DBG("HAS Hearing Aid Features handle at %d", attr->handle);
 		memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
 		discover_params.uuid = &uuid.uuid;
 		discover_params.start_handle = attr->handle + 2;
 		discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
 		subscribe_params = &features_sub;
 		subscribe_params->value_handle = bt_gatt_attr_value_handle(attr);

 		err = bt_gatt_discover(conn, &discover_params);
 		if (err) {
 			LOG_DBG("Discover failed (err %d)", err);
 		}
 	} else if (!bt_uuid_cmp(params->uuid, BT_UUID_GATT_CCC)) {
 		LOG_DBG("CCC handle at %d", attr->handle);
 		subscribe_params = &features_sub;
 		subscribe_params->notify = notify_handler;
 		subscribe_params->value = BT_GATT_CCC_NOTIFY;
 		subscribe_params->ccc_handle = attr->handle;
 		subscribe_params->subscribe = subscribe_cb;

 		err = bt_gatt_subscribe(conn, subscribe_params);
 		if (err && err != -EALREADY) {
 			LOG_DBG("Subscribe failed (err %d)", err);
 		}
 	} else {
 		LOG_DBG("Unknown handle at %d", attr->handle);
 		return BT_GATT_ITER_CONTINUE;
 	}

 	return BT_GATT_ITER_STOP;
 }

 static void discover_and_subscribe_features(void)
 {
 	int err = 0;

 	LOG_DBG("%s", __func__);

 	memcpy(&uuid, BT_UUID_HAS_HEARING_AID_FEATURES, sizeof(uuid));
 	discover_params.uuid = &uuid.uuid;
 	discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
 	discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
 	discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
 	discover_params.func = discover_features_cb;

 	err = bt_gatt_discover(default_conn, &discover_params);
 	if (err != 0) {
 		FAIL("Service Discovery failed (err %d)\n", err);
 		return;
 	}
 }

 static uint8_t discover_active_preset_index_cb(struct bt_conn *conn,
 					       const struct bt_gatt_attr *attr,
 					       struct bt_gatt_discover_params *params)
 {
 	struct bt_gatt_subscribe_params *subscribe_params;
 	int err;

 	if (!attr) {
 		LOG_DBG("Discover complete");
 		(void)memset(params, 0, sizeof(*params));
 		return BT_GATT_ITER_STOP;
 	}

 	if (!bt_uuid_cmp(params->uuid, BT_UUID_HAS_ACTIVE_PRESET_INDEX)) {
 		LOG_DBG("HAS Hearing Aid Features handle at %d", attr->handle);
 		memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
 		discover_params.uuid = &uuid.uuid;
 		discover_params.start_handle = attr->handle + 2;
 		discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
 		subscribe_params = &active_preset_index_sub;
 		subscribe_params->value_handle = bt_gatt_attr_value_handle(attr);

 		err = bt_gatt_discover(conn, &discover_params);
 		if (err) {
 			LOG_DBG("Discover failed (err %d)", err);
 		}
 	} else if (!bt_uuid_cmp(params->uuid, BT_UUID_GATT_CCC)) {
 		LOG_DBG("CCC handle at %d", attr->handle);
 		subscribe_params = &active_preset_index_sub;
 		subscribe_params->notify = notify_handler;
 		subscribe_params->value = BT_GATT_CCC_NOTIFY;
 		subscribe_params->ccc_handle = attr->handle;
 		subscribe_params->subscribe = subscribe_cb;

 		err = bt_gatt_subscribe(conn, subscribe_params);
 		if (err && err != -EALREADY) {
 			LOG_DBG("Subscribe failed (err %d)", err);
 		}
 	} else {
 		LOG_DBG("Unknown handle at %d", attr->handle);
 		return BT_GATT_ITER_CONTINUE;
 	}

 	return BT_GATT_ITER_STOP;
 }

 static void discover_and_subscribe_active_preset_index(void)
 {
 	int err = 0;

 	LOG_DBG("%s", __func__);

 	memcpy(&uuid, BT_UUID_HAS_ACTIVE_PRESET_INDEX, sizeof(uuid));
 	discover_params.uuid = &uuid.uuid;
 	discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
 	discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
 	discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
 	discover_params.func = discover_active_preset_index_cb;

 	err = bt_gatt_discover(default_conn, &discover_params);
 	if (err != 0) {
 		FAIL("Service Discovery failed (err %d)\n", err);
 		return;
 	}
 }

 static uint8_t discover_control_point_cb(struct bt_conn *conn, const struct bt_gatt_attr *attr,
 					 struct bt_gatt_discover_params *params)
 {
 	struct bt_gatt_subscribe_params *subscribe_params;
 	int err;

 	if (!attr) {
 		LOG_DBG("Discover complete");
 		(void)memset(params, 0, sizeof(*params));
 		return BT_GATT_ITER_STOP;
 	}

 	if (!bt_uuid_cmp(params->uuid, BT_UUID_HAS_PRESET_CONTROL_POINT)) {
 		LOG_DBG("HAS Control Point handle at %d", attr->handle);
 		memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
 		discover_params.uuid = &uuid.uuid;
 		discover_params.start_handle = attr->handle + 2;
 		discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
 		subscribe_params = &control_point_sub;
 		subscribe_params->value_handle = bt_gatt_attr_value_handle(attr);

 		err = bt_gatt_discover(conn, &discover_params);
 		if (err) {
 			LOG_DBG("Discover failed (err %d)", err);
 		}
 	} else if (!bt_uuid_cmp(params->uuid, BT_UUID_GATT_CCC)) {
 		LOG_DBG("CCC handle at %d", attr->handle);
 		subscribe_params = &control_point_sub;
 		subscribe_params->notify = notify_handler;
 		subscribe_params->value = BT_GATT_CCC_INDICATE;
 		subscribe_params->ccc_handle = attr->handle;
 		subscribe_params->subscribe = subscribe_cb;

 		err = bt_gatt_subscribe(conn, subscribe_params);
 		if (err && err != -EALREADY) {
 			LOG_DBG("Subscribe failed (err %d)", err);
 		}
 	} else {
 		LOG_DBG("Unknown handle at %d", attr->handle);
 		return BT_GATT_ITER_CONTINUE;
 	}

 	return BT_GATT_ITER_STOP;
 }

 static void discover_and_subscribe_control_point(void)
 {
 	int err = 0;

 	LOG_DBG("%s", __func__);

 	memcpy(&uuid, BT_UUID_HAS_PRESET_CONTROL_POINT, sizeof(uuid));
 	discover_params.uuid = &uuid.uuid;
 	discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
 	discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
 	discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
 	discover_params.func = discover_control_point_cb;

 	err = bt_gatt_discover(default_conn, &discover_params);
 	if (err != 0) {
 		FAIL("Control Point failed (err %d)\n", err);
 		return;
 	}
 }

 static void test_gatt_client(void)
 {
 	int err;

 	err = bt_enable(NULL);
 	if (err < 0) {
 		FAIL("Bluetooth discover failed (err %d)\n", err);
 		return;
 	}

 	LOG_DBG("Bluetooth initialized");

 	bt_le_scan_cb_register(&common_scan_cb);

 	err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, NULL);
 	if (err < 0) {
 		FAIL("Scanning failed to start (err %d)\n", err);
 		return;
 	}

 	LOG_DBG("Scanning successfully started");

 	WAIT_FOR_FLAG(flag_connected);

 	err = bt_conn_set_security(default_conn, BT_SECURITY_L2);
 	if (err) {
 		FAIL("Failed to set security level %d (err %d)", BT_SECURITY_L2, err);
 		return;
 	}

 	WAIT_FOR_COND(security_level == BT_SECURITY_L2);

 	discover_and_subscribe_features();
 	WAIT_FOR_FLAG(flag_features_discovered);

 	discover_and_subscribe_active_preset_index();
 	WAIT_FOR_FLAG(flag_active_preset_index_discovered);

 	discover_and_subscribe_control_point();
 	WAIT_FOR_FLAG(flag_control_point_discovered);

 	bt_conn_disconnect(default_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
 	WAIT_FOR_UNSET_FLAG(flag_connected);

 	notify_received_mask = 0;
 	UNSET_FLAG(flag_all_notifications_received);

 	err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, NULL);
 	if (err < 0) {
 		FAIL("Scanning failed to start (err %d)\n", err);
 		return;
 	}

 	LOG_DBG("Scanning successfully started");

 	WAIT_FOR_FLAG(flag_connected);

 	err = bt_conn_set_security(default_conn, BT_SECURITY_L2);
 	if (err) {
 		FAIL("Failed to set security level %d (err %d)\n", BT_SECURITY_L2, err);
 		return;
 	}

 	WAIT_FOR_FLAG(flag_all_notifications_received);

 	PASS("HAS main PASS\n");
 }

 static const struct bst_test_instance test_has[] = {
 	{
 		.test_id = "has_client",
 		.test_post_init_f = test_init,
 		.test_tick_f = test_tick,
 		.test_main_f = test_main,
 	},
 	{
 		.test_id = "has_client_offline_behavior",
 		.test_descr = "Test receiving notifications after reconnection",
 		.test_post_init_f = test_init,
 		.test_tick_f = test_tick,
 		.test_main_f = test_gatt_client,
 	},
 	BSTEST_END_MARKER
 };

 struct bst_test_list *test_has_client_install(struct bst_test_list *tests)
 {
 	if (IS_ENABLED(CONFIG_BT_HAS_CLIENT)) {
 		return bst_add_tests(tests, test_has);
 	} else {
 		return tests;
 	}
 }
	/*
	* Copyright (c) 2022 Codecoup
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/bluetooth/audio/has.h>

	#include "../../subsys/bluetooth/audio/has_internal.h"

	#include "common.h"

	#include <zephyr/logging/log.h>
	LOG_MODULE_REGISTER(has_client_test, LOG_LEVEL_DBG);

	extern enum bst_result_t bst_result;

	extern const char *test_preset_name_1;
	extern const char *test_preset_name_5;
	extern const uint8_t test_preset_index_1;
	extern const uint8_t test_preset_index_3;
	extern const uint8_t test_preset_index_5;
	extern const enum bt_has_properties test_preset_properties;

	CREATE_FLAG(g_service_discovered);
	CREATE_FLAG(g_preset_switched);
	CREATE_FLAG(g_preset_1_found);
	CREATE_FLAG(g_preset_3_found);
	CREATE_FLAG(g_preset_5_found);

	static struct bt_has *g_has;
	static uint8_t g_active_index;

	static void discover_cb(struct bt_conn conn, int err, struct bt_has has,
	enum bt_has_hearing_aid_type type, enum bt_has_capabilities caps)
	{
	if (err) {
	FAIL("Failed to discover HAS (err %d)\n", err);
	return;
	}

	LOG_DBG("HAS discovered type %d caps %d", type, caps);

	g_has = has;
	SET_FLAG(g_service_discovered);
	}

	static void preset_switch_cb(struct bt_has *has, int err, uint8_t index)
	{
	if (err != 0) {
	return;
	}

	LOG_DBG("Active preset index %d", index);

	SET_FLAG(g_preset_switched);
	g_active_index = index;
	}

	static void check_preset_record(const struct bt_has_preset_record *record,
	enum bt_has_properties expected_properties,
	const char *expected_name)
	{
	if (record->properties != expected_properties \|\| strcmp(record->name, expected_name)) {
	FAIL("mismatch 0x%02x %s vs 0x%02x %s expected\n",
	record->properties, record->name, expected_properties, expected_name);
	}
	}

	static void preset_read_rsp_cb(struct bt_has *has, int err,
	const struct bt_has_preset_record *record, bool is_last)
	{
	if (err) {
	FAIL("%s: err %d\n", __func__, err);
	return;
	}

	if (record->index == test_preset_index_1) {
	SET_FLAG(g_preset_1_found);

	check_preset_record(record, test_preset_properties, test_preset_name_1);
	} else if (record->index == test_preset_index_5) {
	SET_FLAG(g_preset_5_found);

	check_preset_record(record, test_preset_properties, test_preset_name_5);
	} else {
	FAIL("unexpected index 0x%02x", record->index);
	}
	}

	static void preset_update_cb(struct bt_has *has, uint8_t index_prev,
	const struct bt_has_preset_record *record, bool is_last)
	{
	if (record->index == test_preset_index_1) {
	SET_FLAG(g_preset_1_found);
	} else if (record->index == test_preset_index_3) {
	SET_FLAG(g_preset_3_found);
	} else if (record->index == test_preset_index_5) {
	SET_FLAG(g_preset_5_found);
	}
	}

	static const struct bt_has_client_cb has_cb = {
	.discover = discover_cb,
	.preset_switch = preset_switch_cb,
	.preset_read_rsp = preset_read_rsp_cb,
	.preset_update = preset_update_cb,
	};

	static bool test_preset_switch(uint8_t index)
	{
	int err;

	UNSET_FLAG(g_preset_switched);

	err = bt_has_client_preset_set(g_has, index, false);
	if (err < 0) {
	LOG_DBG("%s (err %d)", __func__, err);
	return false;
	}

	WAIT_FOR_COND(g_preset_switched);

	return g_active_index == index;
	}

	static bool test_preset_next(uint8_t active_index_expected)
	{
	int err;

	UNSET_FLAG(g_preset_switched);

	err = bt_has_client_preset_next(g_has, false);
	if (err < 0) {
	LOG_DBG("%s (err %d)", __func__, err);
	return false;
	}

	WAIT_FOR_COND(g_preset_switched);

	return g_active_index == active_index_expected;
	}

	static bool test_preset_prev(uint8_t active_index_expected)
	{
	int err;

	UNSET_FLAG(g_preset_switched);

	err = bt_has_client_preset_prev(g_has, false);
	if (err < 0) {
	LOG_DBG("%s (err %d)", __func__, err);
	return false;
	}

	WAIT_FOR_COND(g_preset_switched);

	return g_active_index == active_index_expected;
	}

	static void discover_has(void)
	{
	int err;

	g_service_discovered = false;

	err = bt_has_client_discover(default_conn);
	if (err < 0) {
	FAIL("Failed to discover HAS (err %d)\n", err);
	return;
	}

	WAIT_FOR_COND(g_service_discovered);
	}

	static void test_main(void)
	{
	int err;

	err = bt_enable(NULL);
	if (err < 0) {
	FAIL("Bluetooth discover failed (err %d)\n", err);
	return;
	}

	LOG_DBG("Bluetooth initialized");

	err = bt_has_client_cb_register(&has_cb);
	if (err < 0) {
	FAIL("Failed to register callbacks (err %d)\n", err);
	return;
	}

	bt_le_scan_cb_register(&common_scan_cb);

	err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, NULL);
	if (err < 0) {
	FAIL("Scanning failed to start (err %d)\n", err);
	return;
	}

	LOG_DBG("Scanning successfully started");

	WAIT_FOR_FLAG(flag_connected);

	discover_has();
	WAIT_FOR_COND(g_preset_switched);

	err = bt_has_client_presets_read(g_has, BT_HAS_PRESET_INDEX_FIRST, 255);
	if (err < 0) {
	FAIL("Failed to read presets (err %d)\n", err);
	return;
	}

	WAIT_FOR_COND(g_preset_1_found);
	WAIT_FOR_COND(g_preset_5_found);

	if (!test_preset_switch(test_preset_index_1)) {
	FAIL("Failed to switch preset %d\n", test_preset_index_1);
	return;
	}

	if (!test_preset_switch(test_preset_index_5)) {
	FAIL("Failed to switch preset %d\n", test_preset_index_5);
	return;
	}

	if (!test_preset_next(test_preset_index_1)) {
	FAIL("Failed to set next preset %d\n", test_preset_index_1);
	return;
	}

	if (!test_preset_next(test_preset_index_5)) {
	FAIL("Failed to set next preset %d\n", test_preset_index_5);
	return;
	}

	if (!test_preset_next(test_preset_index_1)) {
	FAIL("Failed to set next preset %d\n", test_preset_index_1);
	return;
	}

	if (!test_preset_prev(test_preset_index_5)) {
	FAIL("Failed to set previous preset %d\n", test_preset_index_5);
	return;
	}

	if (!test_preset_prev(test_preset_index_1)) {
	FAIL("Failed to set previous preset %d\n", test_preset_index_1);
	return;
	}

	if (!test_preset_prev(test_preset_index_5)) {
	FAIL("Failed to set previous preset %d\n", test_preset_index_5);
	return;
	}

	PASS("HAS main PASS\n");
	}

	#define FEATURES_SUB_NTF BIT(0)
	#define ACTIVE_INDEX_SUB_NTF BIT(1)
	#define PRESET_CHANGED_SUB_NTF BIT(2)
	#define SUB_NTF_ALL (FEATURES_SUB_NTF \| ACTIVE_INDEX_SUB_NTF \| PRESET_CHANGED_SUB_NTF)

	CREATE_FLAG(flag_features_discovered);
	CREATE_FLAG(flag_active_preset_index_discovered);
	CREATE_FLAG(flag_control_point_discovered);
	CREATE_FLAG(flag_all_notifications_received);

	enum preset_state {
	STATE_UNKNOWN,
	STATE_AVAILABLE,
	STATE_UNAVAILABLE,
	STATE_DELETED,
	};

	static enum preset_state preset_state_1;
	static enum preset_state preset_state_3;
	static enum preset_state preset_state_5;

	static struct bt_uuid_16 uuid = BT_UUID_INIT_16(0);
	static struct bt_gatt_discover_params discover_params;
	static struct bt_gatt_subscribe_params features_sub;
	static struct bt_gatt_subscribe_params active_preset_index_sub;
	static struct bt_gatt_subscribe_params control_point_sub;
	static uint8_t notify_received_mask;

	static void preset_availability_changed(uint8_t index, bool available)
	{
	enum preset_state state = available ? STATE_AVAILABLE : STATE_UNAVAILABLE;

	if (index == test_preset_index_1) {
	preset_state_1 = state;
	} else if (index == test_preset_index_3) {
	preset_state_3 = state;
	} else if (index == test_preset_index_5) {
	preset_state_5 = state;
	} else {
	FAIL("invalid preset index 0x%02x", index);
	}
	}

	static uint8_t notify_handler(struct bt_conn conn, struct bt_gatt_subscribe_params params,
	const void *data, uint16_t length)
	{
	LOG_DBG("conn %p params %p data %p length %u", (void *)conn, params, data, length);

	if (params == &features_sub) {
	if (data == NULL) {
	LOG_DBG("features_sub [UNSUBSCRIBED]");
	return BT_GATT_ITER_STOP;
	}

	LOG_DBG("Received features_sub notification");
	notify_received_mask \|= FEATURES_SUB_NTF;
	} else if (params == &active_preset_index_sub) {
	if (data == NULL) {
	LOG_DBG("active_preset_index_sub_sub [UNSUBSCRIBED]");
	return BT_GATT_ITER_STOP;
	}

	LOG_DBG("Received active_preset_index_sub_sub notification");
	notify_received_mask \|= ACTIVE_INDEX_SUB_NTF;
	} else if (params == &control_point_sub) {
	const struct bt_has_cp_hdr *hdr;

	if (data == NULL) {
	LOG_DBG("control_point_sub [UNSUBSCRIBED]");
	return BT_GATT_ITER_STOP;
	}

	if (length < sizeof(*hdr)) {
	FAIL("malformed bt_has_cp_hdr");
	return BT_GATT_ITER_STOP;
	}

	hdr = data;

	if (hdr->opcode == BT_HAS_OP_PRESET_CHANGED) {
	const struct bt_has_cp_preset_changed *pc;

	if (length < (sizeof(hdr) + sizeof(pc))) {
	FAIL("malformed bt_has_cp_preset_changed");
	return BT_GATT_ITER_STOP;
	}

	pc = (const void *)hdr->data;

	switch (pc->change_id) {
	case BT_HAS_CHANGE_ID_GENERIC_UPDATE: {
	const struct bt_has_cp_generic_update *gu;
	bool is_available;

	if (length < (sizeof(hdr) + sizeof(pc) + sizeof(*gu))) {
	FAIL("malformed bt_has_cp_generic_update");
	return BT_GATT_ITER_STOP;
	}

	gu = (const void *)pc->additional_params;

	LOG_DBG("Received generic update index 0x%02x props 0x%02x",
	gu->index, gu->properties);

	is_available = (gu->properties & BT_HAS_PROP_AVAILABLE) != 0;

	preset_availability_changed(gu->index, is_available);
	break;
	}
	default:
	LOG_DBG("Unexpected Change ID 0x%02x", pc->change_id);
	return BT_GATT_ITER_STOP;
	}

	if (pc->is_last) {
	notify_received_mask \|= PRESET_CHANGED_SUB_NTF;
	}
	} else {
	LOG_DBG("Unexpected opcode 0x%02x", hdr->opcode);
	return BT_GATT_ITER_STOP;
	}
	}

	LOG_DBG("pacs_instance.notify_received_mask is %d", notify_received_mask);

	if (notify_received_mask == SUB_NTF_ALL) {
	SET_FLAG(flag_all_notifications_received);
	notify_received_mask = 0;
	}

	return BT_GATT_ITER_CONTINUE;
	}

	static void subscribe_cb(struct bt_conn conn, uint8_t err, struct bt_gatt_subscribe_params params)
	{
	if (err != BT_ATT_ERR_SUCCESS) {
	return;
	}

	LOG_DBG("[SUBSCRIBED]");

	if (params == &features_sub) {
	SET_FLAG(flag_features_discovered);
	return;
	}

	if (params == &control_point_sub) {
	SET_FLAG(flag_control_point_discovered);
	return;
	}

	if (params == &active_preset_index_sub) {
	SET_FLAG(flag_active_preset_index_discovered);
	return;
	}
	}

	static uint8_t discover_features_cb(struct bt_conn conn, const struct bt_gatt_attr attr,
	struct bt_gatt_discover_params *params)
	{
	struct bt_gatt_subscribe_params *subscribe_params;
	int err;

	if (!attr) {
	LOG_DBG("Discover complete");
	(void)memset(params, 0, sizeof(*params));
	return BT_GATT_ITER_STOP;
	}

	if (!bt_uuid_cmp(params->uuid, BT_UUID_HAS_HEARING_AID_FEATURES)) {
	LOG_DBG("HAS Hearing Aid Features handle at %d", attr->handle);
	memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
	discover_params.uuid = &uuid.uuid;
	discover_params.start_handle = attr->handle + 2;
	discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
	subscribe_params = &features_sub;
	subscribe_params->value_handle = bt_gatt_attr_value_handle(attr);

	err = bt_gatt_discover(conn, &discover_params);
	if (err) {
	LOG_DBG("Discover failed (err %d)", err);
	}
	} else if (!bt_uuid_cmp(params->uuid, BT_UUID_GATT_CCC)) {
	LOG_DBG("CCC handle at %d", attr->handle);
	subscribe_params = &features_sub;
	subscribe_params->notify = notify_handler;
	subscribe_params->value = BT_GATT_CCC_NOTIFY;
	subscribe_params->ccc_handle = attr->handle;
	subscribe_params->subscribe = subscribe_cb;

	err = bt_gatt_subscribe(conn, subscribe_params);
	if (err && err != -EALREADY) {
	LOG_DBG("Subscribe failed (err %d)", err);
	}
	} else {
	LOG_DBG("Unknown handle at %d", attr->handle);
	return BT_GATT_ITER_CONTINUE;
	}

	return BT_GATT_ITER_STOP;
	}

	static void discover_and_subscribe_features(void)
	{
	int err = 0;

	LOG_DBG("%s", __func__);

	memcpy(&uuid, BT_UUID_HAS_HEARING_AID_FEATURES, sizeof(uuid));
	discover_params.uuid = &uuid.uuid;
	discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
	discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
	discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
	discover_params.func = discover_features_cb;

	err = bt_gatt_discover(default_conn, &discover_params);
	if (err != 0) {
	FAIL("Service Discovery failed (err %d)\n", err);
	return;
	}
	}

	static uint8_t discover_active_preset_index_cb(struct bt_conn *conn,
	const struct bt_gatt_attr *attr,
	struct bt_gatt_discover_params *params)
	{
	struct bt_gatt_subscribe_params *subscribe_params;
	int err;

	if (!attr) {
	LOG_DBG("Discover complete");
	(void)memset(params, 0, sizeof(*params));
	return BT_GATT_ITER_STOP;
	}

	if (!bt_uuid_cmp(params->uuid, BT_UUID_HAS_ACTIVE_PRESET_INDEX)) {
	LOG_DBG("HAS Hearing Aid Features handle at %d", attr->handle);
	memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
	discover_params.uuid = &uuid.uuid;
	discover_params.start_handle = attr->handle + 2;
	discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
	subscribe_params = &active_preset_index_sub;
	subscribe_params->value_handle = bt_gatt_attr_value_handle(attr);

	err = bt_gatt_discover(conn, &discover_params);
	if (err) {
	LOG_DBG("Discover failed (err %d)", err);
	}
	} else if (!bt_uuid_cmp(params->uuid, BT_UUID_GATT_CCC)) {
	LOG_DBG("CCC handle at %d", attr->handle);
	subscribe_params = &active_preset_index_sub;
	subscribe_params->notify = notify_handler;
	subscribe_params->value = BT_GATT_CCC_NOTIFY;
	subscribe_params->ccc_handle = attr->handle;
	subscribe_params->subscribe = subscribe_cb;

	err = bt_gatt_subscribe(conn, subscribe_params);
	if (err && err != -EALREADY) {
	LOG_DBG("Subscribe failed (err %d)", err);
	}
	} else {
	LOG_DBG("Unknown handle at %d", attr->handle);
	return BT_GATT_ITER_CONTINUE;
	}

	return BT_GATT_ITER_STOP;
	}

	static void discover_and_subscribe_active_preset_index(void)
	{
	int err = 0;

	LOG_DBG("%s", __func__);

	memcpy(&uuid, BT_UUID_HAS_ACTIVE_PRESET_INDEX, sizeof(uuid));
	discover_params.uuid = &uuid.uuid;
	discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
	discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
	discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
	discover_params.func = discover_active_preset_index_cb;

	err = bt_gatt_discover(default_conn, &discover_params);
	if (err != 0) {
	FAIL("Service Discovery failed (err %d)\n", err);
	return;
	}
	}

	static uint8_t discover_control_point_cb(struct bt_conn conn, const struct bt_gatt_attr attr,
	struct bt_gatt_discover_params *params)
	{
	struct bt_gatt_subscribe_params *subscribe_params;
	int err;

	if (!attr) {
	LOG_DBG("Discover complete");
	(void)memset(params, 0, sizeof(*params));
	return BT_GATT_ITER_STOP;
	}

	if (!bt_uuid_cmp(params->uuid, BT_UUID_HAS_PRESET_CONTROL_POINT)) {
	LOG_DBG("HAS Control Point handle at %d", attr->handle);
	memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
	discover_params.uuid = &uuid.uuid;
	discover_params.start_handle = attr->handle + 2;
	discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
	subscribe_params = &control_point_sub;
	subscribe_params->value_handle = bt_gatt_attr_value_handle(attr);

	err = bt_gatt_discover(conn, &discover_params);
	if (err) {
	LOG_DBG("Discover failed (err %d)", err);
	}
	} else if (!bt_uuid_cmp(params->uuid, BT_UUID_GATT_CCC)) {
	LOG_DBG("CCC handle at %d", attr->handle);
	subscribe_params = &control_point_sub;
	subscribe_params->notify = notify_handler;
	subscribe_params->value = BT_GATT_CCC_INDICATE;
	subscribe_params->ccc_handle = attr->handle;
	subscribe_params->subscribe = subscribe_cb;

	err = bt_gatt_subscribe(conn, subscribe_params);
	if (err && err != -EALREADY) {
	LOG_DBG("Subscribe failed (err %d)", err);
	}
	} else {
	LOG_DBG("Unknown handle at %d", attr->handle);
	return BT_GATT_ITER_CONTINUE;
	}

	return BT_GATT_ITER_STOP;
	}

	static void discover_and_subscribe_control_point(void)
	{
	int err = 0;

	LOG_DBG("%s", __func__);

	memcpy(&uuid, BT_UUID_HAS_PRESET_CONTROL_POINT, sizeof(uuid));
	discover_params.uuid = &uuid.uuid;
	discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
	discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
	discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
	discover_params.func = discover_control_point_cb;

	err = bt_gatt_discover(default_conn, &discover_params);
	if (err != 0) {
	FAIL("Control Point failed (err %d)\n", err);
	return;
	}
	}

	static void test_gatt_client(void)
	{
	int err;

	err = bt_enable(NULL);
	if (err < 0) {
	FAIL("Bluetooth discover failed (err %d)\n", err);
	return;
	}

	LOG_DBG("Bluetooth initialized");

	bt_le_scan_cb_register(&common_scan_cb);

	err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, NULL);
	if (err < 0) {
	FAIL("Scanning failed to start (err %d)\n", err);
	return;
	}

	LOG_DBG("Scanning successfully started");

	WAIT_FOR_FLAG(flag_connected);

	err = bt_conn_set_security(default_conn, BT_SECURITY_L2);
	if (err) {
	FAIL("Failed to set security level %d (err %d)", BT_SECURITY_L2, err);
	return;
	}

	WAIT_FOR_COND(security_level == BT_SECURITY_L2);

	discover_and_subscribe_features();
	WAIT_FOR_FLAG(flag_features_discovered);

	discover_and_subscribe_active_preset_index();
	WAIT_FOR_FLAG(flag_active_preset_index_discovered);

	discover_and_subscribe_control_point();
	WAIT_FOR_FLAG(flag_control_point_discovered);

	bt_conn_disconnect(default_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
	WAIT_FOR_UNSET_FLAG(flag_connected);

	notify_received_mask = 0;
	UNSET_FLAG(flag_all_notifications_received);

	err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, NULL);
	if (err < 0) {
	FAIL("Scanning failed to start (err %d)\n", err);
	return;
	}

	LOG_DBG("Scanning successfully started");

	WAIT_FOR_FLAG(flag_connected);

	err = bt_conn_set_security(default_conn, BT_SECURITY_L2);
	if (err) {
	FAIL("Failed to set security level %d (err %d)\n", BT_SECURITY_L2, err);
	return;
	}

	WAIT_FOR_FLAG(flag_all_notifications_received);

	PASS("HAS main PASS\n");
	}

	static const struct bst_test_instance test_has[] = {
	{
	.test_id = "has_client",
	.test_post_init_f = test_init,
	.test_tick_f = test_tick,
	.test_main_f = test_main,
	},
	{
	.test_id = "has_client_offline_behavior",
	.test_descr = "Test receiving notifications after reconnection",
	.test_post_init_f = test_init,
	.test_tick_f = test_tick,
	.test_main_f = test_gatt_client,
	},
	BSTEST_END_MARKER
	};

	struct bst_test_list test_has_client_install(struct bst_test_list tests)
	{
	if (IS_ENABLED(CONFIG_BT_HAS_CLIENT)) {
	return bst_add_tests(tests, test_has);
	} else {
	return tests;
	}
	}