自学教程：C++ tester_test_failed函数代码示例

static void server_hook_func(const void *data, uint16_t len,							void *user_data){	struct test_data *test_data = tester_get_data();	const struct rfcomm_server_data *server_data = test_data->test_data;	ssize_t ret;	if (server_data->data_len != len) {		tester_test_failed();		return;	}	ret = memcmp(server_data->send_data, data, len);	if (ret)		tester_test_failed();	else		tester_test_passed();}

static void test_connect(const void *test_data){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	GIOChannel *io;	int sk;	if (l2data->server_psm) {		struct bthost *bthost = hciemu_client_get_host(data->hciemu);		if (!l2data->data_len)			bthost_add_l2cap_server(bthost, l2data->server_psm,						NULL, NULL);		else			bthost_add_l2cap_server(bthost, l2data->server_psm,						client_l2cap_connect_cb, data);	}	if (l2data->direct_advertising)		hciemu_add_master_post_command_hook(data->hciemu,						direct_adv_cmd_complete, NULL);	sk = create_l2cap_sock(data, 0, l2data->cid, l2data->sec_level);	if (sk < 0) {		tester_test_failed();		return;	}	if (connect_l2cap_sock(data, sk, l2data->client_psm,							l2data->cid) < 0) {		close(sk);		tester_test_failed();		return;	}	io = g_io_channel_unix_new(sk);	g_io_channel_set_close_on_unref(io, TRUE);	data->io_id = g_io_add_watch(io, G_IO_OUT, l2cap_connect_cb, NULL);	g_io_channel_unref(io);	tester_print("Connect in progress");}

static void test_le_generate_dhkey_status(const void *data, uint8_t size,							void *user_data){	uint8_t status = *((uint8_t *) data);	if (status) {		tester_warn("Failed to send DHKey gen cmd (0x%02x)", status);		tester_test_failed();		return;	}}

static void test_le_read_local_pk_status(const void *data, uint8_t size,							void *user_data){	uint8_t status = *((uint8_t *) data);	if (status) {		tester_warn("Failed to send Read Local PK256 cmd (0x%02x)", status);		tester_test_failed();		return;	}}

static void test_connect_reject(const void *test_data){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	int sk;	sk = create_l2cap_sock(data, 0, l2data->cid, l2data->sec_level);	if (sk < 0) {		tester_test_failed();		return;	}	if (connect_l2cap_sock(data, sk, l2data->client_psm,							l2data->cid) < 0)		tester_test_passed();	else		tester_test_failed();	close(sk);}

static void test_command(uint16_t opcode){	struct user_data *user = tester_get_data();	if (!bt_hci_send(user->hci_ut, opcode, NULL, 0,					test_command_complete, NULL, NULL)) {		tester_warn("Failed to send HCI command 0x%04x", opcode);		tester_test_failed();		return;	}}

static void test_inquiry_status(const void *data, uint8_t size,							void *user_data){	uint8_t status = *((uint8_t *) data);	if (status) {		tester_warn("HCI inquiry command failed (0x%02x)", status);		tester_test_failed();		return;	}}

static void test_le_generate_dhkey_complete(const void *data, uint8_t size,								void *user_data){	const uint8_t *event = data;	const struct bt_hci_evt_le_generate_dhkey_complete *evt;	struct le_keys *keys = user_data;	uint8_t dhkey[32];	if (*event != BT_HCI_EVT_LE_GENERATE_DHKEY_COMPLETE) {		tester_warn("Failed DHKey generation command");		tester_test_failed();		return;	}	evt = (void *)(event + 1);	if (evt->status) {		tester_warn("HCI Generate DHKey complete failed (0x%02x)",								evt->status);		tester_test_failed();		return;	}	util_hexdump('>', evt->dhkey, 32, test_debug, NULL);	util_hexdump('S', keys->remote_sk, 32, test_debug, NULL);	util_hexdump('P', keys->local_pk, 64, test_debug, NULL);	/* Generate DHKey ourself with local public key and remote	 * private key we got when generated public / private key	 * pair for BT_HCI_CMD_LE_GENERATE_DHKEY argument.	 */	ecdh_shared_secret(keys->local_pk, keys->remote_sk, dhkey);	util_hexdump('D', dhkey, 32, test_debug, NULL);	if (!memcmp(dhkey, evt->dhkey, 32))		tester_test_passed();	else		tester_test_failed();}

static void test_create_connection_status(const void *data, uint8_t size,							void *user_data){	uint8_t status = *((uint8_t *) data);	if (status) {		tester_warn("HCI create connection command failed (0x%02x)",								status);		tester_test_failed();		return;	}}

static gboolean test_close_socket_1_part_3(gpointer arg){	struct test_data *data = tester_get_data();	tester_print("Checking whether scan was properly stopped...");	if (data->sk != -1) {		tester_print("Error - scan was not enabled yet");		tester_test_failed();		return FALSE;	}	if (hciemu_get_master_le_scan_enable(data->hciemu)) {		tester_print("Delayed check whether scann is off failed");		tester_test_failed();		return FALSE;	}	tester_test_passed();	return FALSE;}

static void pair_device_complete(uint8_t status, uint16_t length,					const void *param, void *user_data){	if (status != MGMT_STATUS_SUCCESS) {		tester_warn("Pairing failed: %s", mgmt_errstr(status));		tester_test_failed();		return;	}	tester_print("Pairing succeedded");	tester_test_passed();}

static void test_command_complete(const void *data, uint8_t size,							void *user_data){	uint8_t status = *((uint8_t *) data);	if (status) {		tester_warn("HCI command failed (0x%02x)", status);		tester_test_failed();		return;	}	tester_test_passed();}

static void test_server(const void *test_data){	struct test_data *data = tester_get_data();	const struct rfcomm_server_data *server_data = data->test_data;	const uint8_t *master_addr;	struct bthost *bthost;	GIOChannel *io;	int sk;	master_addr = hciemu_get_master_bdaddr(data->hciemu);	sk = create_rfcomm_sock((bdaddr_t *) master_addr,						server_data->server_channel);	if (sk < 0) {		tester_test_failed();		return;	}	if (listen(sk, 5) < 0) {		tester_warn("listening on socket failed: %s (%u)",				strerror(errno), errno);		tester_test_failed();		close(sk);		return;	}	io = g_io_channel_unix_new(sk);	g_io_channel_set_close_on_unref(io, TRUE);	data->io_id = g_io_add_watch(io, G_IO_IN, rfcomm_listen_cb, NULL);	g_io_channel_unref(io);	tester_print("Listening for connections");	bthost = hciemu_client_get_host(data->hciemu);	bthost_set_connect_cb(bthost, client_new_conn, data);	bthost_hci_connect(bthost, master_addr, BDADDR_BREDR);}

static gboolean server_received_data(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	char buf[1024];	int sk;	sk = g_io_channel_unix_get_fd(io);	if (read(sk, buf, l2data->data_len) != l2data->data_len) {		tester_warn("Unable to read %u bytes", l2data->data_len);		tester_test_failed();		return FALSE;	}	if (memcmp(buf, l2data->read_data, l2data->data_len))		tester_test_failed();	else		tester_test_passed();	return FALSE;}

static void test_connect_transp(const void *test_data){	struct test_data *data = tester_get_data();	const struct sco_client_data *scodata = data->test_data;	int sk, err;	struct bt_voice voice;	sk = create_sco_sock(data);	if (sk < 0) {		tester_test_failed();		return;	}	memset(&voice, 0, sizeof(voice));	voice.setting = BT_VOICE_TRANSPARENT;	err = setsockopt(sk, SOL_BLUETOOTH, BT_VOICE, &voice, sizeof(voice));	if (err < 0) {		tester_warn("Can't set socket option : %s (%d)",							strerror(errno), errno);		tester_test_failed();		goto end;	}	err = connect_sco_sock(data, sk);	tester_warn("Connect returned %s (%d), expected %s (%d)",			strerror(-err), -err,			strerror(scodata->expect_err), scodata->expect_err);	if (-err != scodata->expect_err)		tester_test_failed();	else		tester_test_passed();end:	close(sk);}

static void test_local_extended_features_complete(const void *data,						uint8_t size, void *user_data){	const struct bt_hci_rsp_read_local_ext_features *rsp = data;	if (rsp->status) {		tester_warn("Failed to get HCI extended features (0x%02x)",								rsp->status);		tester_test_failed();		return;	}	tester_test_passed();}

static void test_inquiry_complete(const void *data, uint8_t size,							void *user_data){	const struct bt_hci_evt_inquiry_complete *evt = data;	if (evt->status) {		tester_warn("HCI inquiry complete failed (0x%02x)",							evt->status);		tester_test_failed();		return;	}	tester_test_passed();}

static void test_open_failed(const void *test_data){	struct test_data *data = tester_get_data();	struct bt_hci *hci;	hci = bt_hci_new_user_channel(data->mgmt_index);	if (!hci) {		tester_test_passed();		return;	}	bt_hci_unref(hci);	tester_test_failed();}

static void client_l2cap_rsp(uint8_t code, const void *data, uint16_t len,							void *user_data){	struct test_data *test_data = user_data;	const struct l2cap_data *l2data = test_data->test_data;	tester_print("Client received response code 0x%02x", code);	if (code != l2data->expect_cmd_code) {		tester_warn("Unexpected L2CAP response code (expected 0x%02x)",						l2data->expect_cmd_code);		goto failed;	}	if (code == BT_L2CAP_PDU_CONN_RSP) {		const struct bt_l2cap_pdu_conn_rsp *rsp = data;		if (len == sizeof(rsp) && !rsp->result && !rsp->status)			return;		test_data->dcid = rsp->dcid;		test_data->scid = rsp->scid;		if (l2data->data_len)			return;	}	if (!l2data->expect_cmd) {		tester_test_passed();		return;	}	if (l2data->expect_cmd_len != len) {		tester_warn("Unexpected L2CAP response length (%u != %u)",						len, l2data->expect_cmd_len);		goto failed;	}	if (memcmp(l2data->expect_cmd, data, len) != 0) {		tester_warn("Unexpected L2CAP response");		goto failed;	}	tester_test_passed();	return;failed:	tester_test_failed();}

static gboolean client_received_data(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	const struct rfcomm_client_data *client_data = data->test_data;	int sk;	ssize_t ret;	char buf[248];	sk = g_io_channel_unix_get_fd(io);	ret = read(sk, buf, client_data->data_len);	if (client_data->data_len != ret) {		tester_test_failed();		return false;	}	if (memcmp(client_data->read_data, buf, client_data->data_len))		tester_test_failed();	else		tester_test_passed();	return false;}

static void bthost_send_rsp(const void *buf, uint16_t len, void *user_data){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	struct bthost *bthost;	if (l2data->expect_cmd_len && len != l2data->expect_cmd_len) {		tester_test_failed();		return;	}	if (l2data->expect_cmd && memcmp(buf, l2data->expect_cmd,						l2data->expect_cmd_len)) {		tester_test_failed();		return;	}	if (!l2data->send_cmd)		return;	bthost = hciemu_client_get_host(data->hciemu);	bthost_send_cid(bthost, data->handle, data->dcid,				l2data->send_cmd, l2data->send_cmd_len);}

static gboolean server_received_data(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	const struct rfcomm_server_data *server_data = data->test_data;	char buf[1024];	ssize_t ret;	int sk;	sk = g_io_channel_unix_get_fd(io);	ret = read(sk, buf, server_data->data_len);	if (ret != server_data->data_len) {		tester_test_failed();		return false;	}	if (memcmp(buf, server_data->read_data, server_data->data_len))		tester_test_failed();	else		tester_test_passed();	return false;}

static gboolean test_close_socket_2_part_3(gpointer arg){	struct test_data *data = tester_get_data();	int sk = data->sk;	int err;	/* Scan should be already over, we're trying to create connection */	if (hciemu_get_master_le_scan_enable(data->hciemu)) {		tester_print("Error - should no longer scan");		tester_test_failed();		return FALSE;	}	/* Calling close() should eventually cause CMD_LE_CREATE_CONN_CANCEL */	err = close(sk);	if (err < 0) {		tester_print("Error when closing socket");		tester_test_failed();		return FALSE;	}	/* CMD_LE_CREATE_CONN_CANCEL will trigger test pass. */	return FALSE;}

static void connect_socket(const uint8_t *client_bdaddr, int *sk_holder,							GIOFunc connect_cb){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	GIOChannel *io;	int sk;	sk = create_l2cap_sock(data, 0, l2data->cid, l2data->sec_level);	if (sk < 0) {		tester_print("Error in create_l2cap_sock");		tester_test_failed();		return;	}	*sk_holder = sk;	if (connect_l2cap_impl(sk, client_bdaddr, BDADDR_LE_PUBLIC,			l2data->client_psm, l2data->cid) < 0) {		tester_print("Error in connect_l2cap_sock");		close(sk);		tester_test_failed();		return;	}	if (connect_cb) {		io = g_io_channel_unix_new(sk);		g_io_channel_set_close_on_unref(io, TRUE);		data->io_id = g_io_add_watch(io, G_IO_OUT, connect_cb, NULL);		g_io_channel_unref(io);	}	tester_print("Connect in progress, sk = %d", sk);}

static void test_le_encrypt_complete(const void *data, uint8_t size,								void *user_data){	const struct bt_hci_rsp_le_encrypt *rsp = data;	uint8_t sample[16] = {		0x7d, 0xf7, 0x6b, 0x0c, 0x1a, 0xb8, 0x99, 0xb3,		0x3e, 0x42, 0xf0, 0x47, 0xb9, 0x1b, 0x54, 0x6f	};	uint8_t enc_data[16];	if (rsp->status) {		tester_warn("Failed HCI LE Encrypt (0x%02x)", rsp->status);		tester_test_failed();		return;	}	swap_buf(rsp->data, enc_data, 16);	util_hexdump('>', enc_data, 16, test_debug, NULL);	if (!memcmp(sample, enc_data, 16))		tester_test_passed();	else		tester_test_failed();}

static void test_getsockopt(const void *test_data){	int sk, err;	socklen_t len;	struct bt_voice voice;	sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);	if (sk < 0) {		tester_warn("Can't create socket: %s (%d)", strerror(errno),									errno);		tester_test_failed();		return;	}	len = sizeof(voice);	memset(&voice, 0, len);	err = getsockopt(sk, SOL_BLUETOOTH, BT_VOICE, &voice, &len);	if (err < 0) {		tester_warn("Can't get socket option : %s (%d)",							strerror(errno), errno);		tester_test_failed();		goto end;	}	if (voice.setting != BT_VOICE_CVSD_16BIT) {		tester_warn("Invalid voice setting");		tester_test_failed();		goto end;	}	tester_test_passed();end:	close(sk);}

static void test_le_read_local_pk(const void *test_data){	struct user_data *user = tester_get_data();	bt_hci_register(user->hci_ut, BT_HCI_EVT_LE_META_EVENT,				test_le_read_local_pk_complete,				(void *)test_data, NULL);	if (!bt_hci_send(user->hci_ut, BT_HCI_CMD_LE_READ_LOCAL_PK256, NULL,				0, test_le_read_local_pk_status,				NULL, NULL)) {		tester_warn("Failed to send HCI LE Read Local PK256 command");		tester_test_failed();		return;	}}

static void test_basic(const void *test_data){	int sk;	sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);	if (sk < 0) {		tester_warn("Can't create socket: %s (%d)", strerror(errno),									errno);		tester_test_failed();		return;	}	close(sk);	tester_test_passed();}

static void test_read_local_extended_features(const void *test_data){	struct user_data *user = tester_get_data();	struct bt_hci_cmd_read_local_ext_features cmd;	cmd.page = 0x00;	if (!bt_hci_send(user->hci_ut, BT_HCI_CMD_READ_LOCAL_EXT_FEATURES,					&cmd, sizeof(cmd),					test_local_extended_features_complete,								NULL, NULL)) {		tester_warn("Failed to send HCI extended features command");		tester_test_failed();		return;	}}

static void teardown_connection(const void *test_data){	struct user_data *user = tester_get_data();	struct bt_hci_cmd_disconnect cmd;	cmd.handle = cpu_to_le16(user->handle_ut);	cmd.reason = 0x13;	if (!bt_hci_send(user->hci_ut, BT_HCI_CMD_DISCONNECT,						&cmd, sizeof(cmd),						teardown_disconnect_status,								NULL, NULL)) {		tester_warn("Failed to send HCI disconnect command");		tester_test_failed();		return;	}}