tests: Bluetooth: CAP Commander Change Microphone mute unittests

Adds unittests for the CAP Commander Change Microphone mute
procedure.

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>

tests/bluetooth/audio/cap_commander/src/test_micp.c

@@ -291,3 +291,219 @@ ZTEST_F(cap_commander_test_micp,
 	err = bt_cap_commander_change_microphone_gain_setting(&param);
 	zassert_equal(-EINVAL, err, "Unexpected return value %d", err);
 }
+
+ZTEST_F(cap_commander_test_micp, test_commander_change_microphone_mute_state)
+{
+	union bt_cap_set_member members[ARRAY_SIZE(fixture->conns)];
+	const struct bt_cap_commander_change_microphone_mute_state_param param = {
+		.type = BT_CAP_SET_TYPE_AD_HOC,
+		.members = members,
+		.count = ARRAY_SIZE(fixture->conns),
+		.mute = true,
+	};
+	int err;
+
+	for (size_t i = 0U; i < ARRAY_SIZE(members); i++) {
+		members[i].member = &fixture->conns[i];
+	}
+
+	err = bt_cap_commander_register_cb(&mock_cap_commander_cb);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	for (size_t i = 0; i < ARRAY_SIZE(fixture->conns); i++) {
+		struct bt_micp_mic_ctlr *mic_ctlr; /* We don't care about this */
+
+		err = bt_cap_commander_discover(&fixture->conns[i]);
+		zassert_equal(0, err, "Unexpected return value %d", err);
+
+		err = bt_micp_mic_ctlr_discover(&fixture->conns[i], &mic_ctlr);
+		zassert_equal(0, err, "Unexpected return value %d", err);
+	}
+
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	zexpect_call_count("bt_cap_commander_cb.microphone_mute_changed", 1,
+			   mock_cap_commander_microphone_mute_changed_cb_fake.call_count);
+}
+
+ZTEST_F(cap_commander_test_micp, test_commander_change_microphone_mute_state_double)
+{
+	union bt_cap_set_member members[ARRAY_SIZE(fixture->conns)];
+	const struct bt_cap_commander_change_microphone_mute_state_param param = {
+		.type = BT_CAP_SET_TYPE_AD_HOC,
+		.members = members,
+		.count = ARRAY_SIZE(fixture->conns),
+		.mute = true,
+	};
+	int err;
+
+	for (size_t i = 0U; i < ARRAY_SIZE(members); i++) {
+		members[i].member = &fixture->conns[i];
+	}
+
+	err = bt_cap_commander_register_cb(&mock_cap_commander_cb);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	for (size_t i = 0; i < ARRAY_SIZE(fixture->conns); i++) {
+		struct bt_micp_mic_ctlr *mic_ctlr; /* We don't care about this */
+
+		err = bt_cap_commander_discover(&fixture->conns[i]);
+		zassert_equal(0, err, "Unexpected return value %d", err);
+
+		err = bt_micp_mic_ctlr_discover(&fixture->conns[i], &mic_ctlr);
+		zassert_equal(0, err, "Unexpected return value %d", err);
+	}
+
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	zexpect_call_count("bt_cap_commander_cb.microphone_mute_changed", 1,
+			   mock_cap_commander_microphone_mute_changed_cb_fake.call_count);
+
+	/* That that it still works as expected if we set the same value twice */
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	zexpect_call_count("bt_cap_commander_cb.microphone_mute_changed", 2,
+			   mock_cap_commander_microphone_mute_changed_cb_fake.call_count);
+}
+
+ZTEST_F(cap_commander_test_micp, test_commander_change_microphone_mute_state_inval_param_null)
+{
+	int err;
+
+	err = bt_cap_commander_change_microphone_mute_state(NULL);
+	zassert_equal(-EINVAL, err, "Unexpected return value %d", err);
+}
+
+ZTEST_F(cap_commander_test_micp,
+	test_commander_change_microphone_mute_state_inval_param_null_members)
+{
+	const struct bt_cap_commander_change_microphone_mute_state_param param = {
+		.type = BT_CAP_SET_TYPE_AD_HOC,
+		.members = NULL,
+		.count = ARRAY_SIZE(fixture->conns),
+		.mute = true,
+	};
+	int err;
+
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(-EINVAL, err, "Unexpected return value %d", err);
+}
+
+ZTEST_F(cap_commander_test_micp,
+	test_commander_change_microphone_mute_state_inval_param_null_member)
+{
+	union bt_cap_set_member members[ARRAY_SIZE(fixture->conns)];
+	const struct bt_cap_commander_change_microphone_mute_state_param param = {
+		.type = BT_CAP_SET_TYPE_AD_HOC,
+		.members = members,
+		.count = ARRAY_SIZE(fixture->conns),
+		.mute = true,
+	};
+	int err;
+
+	for (size_t i = 0U; i < ARRAY_SIZE(members) - 1; i++) {
+		members[i].member = &fixture->conns[i];
+	}
+	members[ARRAY_SIZE(members) - 1].member = NULL;
+
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(-EINVAL, err, "Unexpected return value %d", err);
+}
+
+ZTEST_F(cap_commander_test_micp, test_commander_change_microphone_mute_state_inval_missing_cas)
+{
+	union bt_cap_set_member members[ARRAY_SIZE(fixture->conns)];
+	const struct bt_cap_commander_change_microphone_mute_state_param param = {
+		.type = BT_CAP_SET_TYPE_AD_HOC,
+		.members = members,
+		.count = ARRAY_SIZE(fixture->conns),
+		.mute = true,
+	};
+	int err;
+
+	for (size_t i = 0U; i < ARRAY_SIZE(members); i++) {
+		members[i].member = &fixture->conns[i];
+	}
+
+	err = bt_cap_commander_register_cb(&mock_cap_commander_cb);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	for (size_t i = 0; i < ARRAY_SIZE(fixture->conns); i++) {
+		struct bt_micp_mic_ctlr *mic_ctlr; /* We don't care about this */
+
+		err = bt_micp_mic_ctlr_discover(&fixture->conns[i], &mic_ctlr);
+		zassert_equal(0, err, "Unexpected return value %d", err);
+	}
+
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(-EINVAL, err, "Unexpected return value %d", err);
+}
+
+ZTEST_F(cap_commander_test_micp, test_commander_change_microphone_mute_state_inval_missing_vcs)
+{
+	union bt_cap_set_member members[ARRAY_SIZE(fixture->conns)];
+	const struct bt_cap_commander_change_microphone_mute_state_param param = {
+		.type = BT_CAP_SET_TYPE_AD_HOC,
+		.members = members,
+		.count = ARRAY_SIZE(fixture->conns),
+		.mute = true,
+	};
+	int err;
+
+	for (size_t i = 0U; i < ARRAY_SIZE(members); i++) {
+		members[i].member = &fixture->conns[i];
+	}
+
+	err = bt_cap_commander_register_cb(&mock_cap_commander_cb);
+	zassert_equal(0, err, "Unexpected return value %d", err);
+
+	for (size_t i = 0; i < ARRAY_SIZE(fixture->conns); i++) {
+		err = bt_cap_commander_discover(&fixture->conns[i]);
+		zassert_equal(0, err, "Unexpected return value %d", err);
+	}
+
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(-EINVAL, err, "Unexpected return value %d", err);
+}
+
+ZTEST_F(cap_commander_test_micp, test_commander_change_microphone_mute_state_inval_param_zero_count)
+{
+	union bt_cap_set_member members[ARRAY_SIZE(fixture->conns)];
+	const struct bt_cap_commander_change_microphone_mute_state_param param = {
+		.type = BT_CAP_SET_TYPE_AD_HOC,
+		.members = members,
+		.count = 0U,
+		.mute = true,
+	};
+	int err;
+
+	for (size_t i = 0U; i < ARRAY_SIZE(members); i++) {
+		members[i].member = &fixture->conns[i];
+	}
+
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(-EINVAL, err, "Unexpected return value %d", err);
+}
+
+ZTEST_F(cap_commander_test_micp,
+	test_commander_change_microphone_mute_state_inval_param_inval_count)
+{
+	union bt_cap_set_member members[ARRAY_SIZE(fixture->conns)];
+	const struct bt_cap_commander_change_microphone_mute_state_param param = {
+		.type = BT_CAP_SET_TYPE_AD_HOC,
+		.members = members,
+		.count = CONFIG_BT_MAX_CONN + 1,
+		.mute = true,
+	};
+	int err;
+
+	for (size_t i = 0U; i < ARRAY_SIZE(members); i++) {
+		members[i].member = &fixture->conns[i];
+	}
+
+	err = bt_cap_commander_change_microphone_mute_state(&param);
+	zassert_equal(-EINVAL, err, "Unexpected return value %d", err);
+}

tests/bluetooth/audio/mocks/include/cap_commander.h

@@ -20,6 +20,7 @@ DECLARE_FAKE_VOID_FUNC(mock_cap_commander_discovery_complete_cb, struct bt_conn
 DECLARE_FAKE_VOID_FUNC(mock_cap_commander_volume_changed_cb, struct bt_conn *, int);
 DECLARE_FAKE_VOID_FUNC(mock_cap_commander_volume_mute_changed_cb, struct bt_conn *, int);
 DECLARE_FAKE_VOID_FUNC(mock_cap_commander_volume_offset_changed_cb, struct bt_conn *, int);
+DECLARE_FAKE_VOID_FUNC(mock_cap_commander_microphone_mute_changed_cb, struct bt_conn *, int);
 DECLARE_FAKE_VOID_FUNC(mock_cap_commander_microphone_gain_changed_cb, struct bt_conn *, int);
 
 #endif /* MOCKS_CAP_COMMANDER_H_ */

tests/bluetooth/audio/mocks/src/cap_commander.c

@@ -14,6 +14,7 @@
 	FAKE(mock_cap_commander_volume_changed_cb)                                                 \
 	FAKE(mock_cap_commander_volume_mute_changed_cb)                                            \
 	FAKE(mock_cap_commander_volume_offset_changed_cb)                                          \
+	FAKE(mock_cap_commander_microphone_mute_changed_cb)                                        \
 	FAKE(mock_cap_commander_microphone_gain_changed_cb)
 
 DEFINE_FAKE_VOID_FUNC(mock_cap_commander_discovery_complete_cb, struct bt_conn *, int,
@@ -22,6 +23,7 @@ DEFINE_FAKE_VOID_FUNC(mock_cap_commander_discovery_complete_cb, struct bt_conn *
 DEFINE_FAKE_VOID_FUNC(mock_cap_commander_volume_changed_cb, struct bt_conn *, int);
 DEFINE_FAKE_VOID_FUNC(mock_cap_commander_volume_mute_changed_cb, struct bt_conn *, int);
 DEFINE_FAKE_VOID_FUNC(mock_cap_commander_volume_offset_changed_cb, struct bt_conn *, int);
+DEFINE_FAKE_VOID_FUNC(mock_cap_commander_microphone_mute_changed_cb, struct bt_conn *, int);
 DEFINE_FAKE_VOID_FUNC(mock_cap_commander_microphone_gain_changed_cb, struct bt_conn *, int);
 
 const struct bt_cap_commander_cb mock_cap_commander_cb = {
@@ -34,6 +36,7 @@ const struct bt_cap_commander_cb mock_cap_commander_cb = {
 #endif /* CONFIG_BT_VCP_VOL_CTLR */
 #endif /* CONFIG_BT_VCP_VOL_CTLR */
 #if defined(CONFIG_BT_MICP_MIC_CTLR)
+	.microphone_mute_changed = mock_cap_commander_microphone_mute_changed_cb,
 #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
 	.microphone_gain_changed = mock_cap_commander_microphone_gain_changed_cb,
 #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */