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

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 rc_connect_cb(GIOChannel *io, GIOCondition cond,		gpointer user_data){	struct test_data *data = tester_get_data();	const struct rfcomm_client_data *client_data = data->test_data;	socklen_t len = sizeof(int);	int sk, err, sk_err;	data->io_id = 0;	sk = g_io_channel_unix_get_fd(io);	if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &sk_err, &len) < 0)		err = -errno;	else		err = -sk_err;	if (client_data->expected_connect_err &&				err == client_data->expected_connect_err) {		tester_test_passed();		return false;	}	if (client_data->send_data) {		ssize_t ret;		ret = write(sk, client_data->send_data, client_data->data_len);		if (client_data->data_len != ret)			tester_test_failed();		return false;	} else if (client_data->read_data) {		g_io_add_watch(io, G_IO_IN, client_received_data, NULL);		bthost_send_rfcomm_data(hciemu_client_get_host(data->hciemu),						data->conn_handle,						client_data->client_channel,						client_data->read_data,						client_data->data_len);		return false;	}	if (err < 0)		tester_test_failed();	else		tester_test_passed();	return false;}

static gboolean l2cap_listen_cb(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	int sk, new_sk;	data->io_id = 0;	sk = g_io_channel_unix_get_fd(io);	new_sk = accept(sk, NULL, NULL);	if (new_sk < 0) {		tester_warn("accept failed: %s (%u)", strerror(errno), errno);		tester_test_failed();		return FALSE;	}	tester_print("Successfully connected");	close(new_sk);	tester_test_passed();	return FALSE;}

static gboolean l2cap_listen_cb(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	int sk, new_sk;	data->io_id = 0;	sk = g_io_channel_unix_get_fd(io);	new_sk = accept(sk, NULL, NULL);	if (new_sk < 0) {		tester_warn("accept failed: %s (%u)", strerror(errno), errno);		tester_test_failed();		return FALSE;	}	if (l2data->read_data) {		struct bthost *bthost;		GIOChannel *new_io;		new_io = g_io_channel_unix_new(new_sk);		g_io_channel_set_close_on_unref(new_io, TRUE);		bthost = hciemu_client_get_host(data->hciemu);		g_io_add_watch(new_io, G_IO_IN, server_received_data, NULL);		bthost_send_cid(bthost, data->handle, data->dcid,					l2data->read_data, l2data->data_len);		g_io_channel_unref(new_io);		return FALSE;	} else if (l2data->write_data) {		struct bthost *bthost;		ssize_t ret;		bthost = hciemu_client_get_host(data->hciemu);		bthost_add_cid_hook(bthost, data->handle, data->scid,					server_bthost_received_data, NULL);		ret = write(new_sk, l2data->write_data, l2data->data_len);		close(new_sk);		if (ret != l2data->data_len) {			tester_warn("Unable to write all data");			tester_test_failed();		}		return FALSE;	}	tester_print("Successfully connected");	close(new_sk);	tester_test_passed();	return FALSE;}

static void direct_adv_cmd_complete(uint16_t opcode, const void *param,						uint8_t len, void *user_data){	struct test_data *data = tester_get_data();	const struct bt_hci_cmd_le_set_adv_parameters *cp;	const uint8_t *expect_bdaddr;	if (opcode != BT_HCI_CMD_LE_SET_ADV_PARAMETERS)		return;	tester_print("Received advertising parameters HCI command");	cp = param;	/* Advertising as client should be direct advertising */	if (cp->type != 0x01) {		tester_warn("Invalid advertising type");		tester_test_failed();		return;	}	expect_bdaddr = hciemu_get_client_bdaddr(data->hciemu);	if (memcmp(expect_bdaddr, cp->direct_addr, 6)) {		tester_warn("Invalid direct address in adv params");		tester_test_failed();		return;	}	tester_test_passed();}

static void test_overwrite(const void *data){	char key[18], value[512], *str;	util_create_empty();	sprintf(key, "00:00:00:00:00:00");	memset(value, 0, sizeof(value));	g_assert(textfile_put(test_pathname, key, value) == 0);	snprintf(value, sizeof(value), "Test");	g_assert(textfile_put(test_pathname, key, value) == 0);	g_assert(textfile_put(test_pathname, key, value) == 0);	g_assert(textfile_put(test_pathname, key, value) == 0);	g_assert(textfile_del(test_pathname, key) == 0);	str = textfile_get(test_pathname, key);	tester_debug("%s/n", str);	g_assert(str == NULL);	tester_test_passed();}

static void index_removed_callback(uint16_t index, uint16_t length,					const void *param, void *user_data){	struct test_data *data = tester_get_data();	tester_print("Index Removed callback");	tester_print("  Index: 0x%04x", index);	if (index != data->mgmt_index)		return;	if (data->remove_id) {		mgmt_unregister(data->mgmt, data->remove_id);		data->remove_id = 0;		tester_test_passed();		return;	}	mgmt_unregister_index(data->mgmt, data->mgmt_index);	mgmt_unref(data->mgmt);	data->mgmt = NULL;	tester_post_teardown_complete();}

static gboolean sco_connect_cb(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	const struct sco_client_data *scodata = data->test_data;	int err, sk_err, sk;	socklen_t len = sizeof(sk_err);	data->io_id = 0;	sk = g_io_channel_unix_get_fd(io);	if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &sk_err, &len) < 0)		err = -errno;	else		err = -sk_err;	if (err < 0)		tester_warn("Connect failed: %s (%d)", strerror(-err), -err);	else		tester_print("Successfully connected");	if (-err != scodata->expect_err)		tester_test_failed();	else		tester_test_passed();	return FALSE;}

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;	}	voice.setting = 0;	len = sizeof(voice);	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_complete(const void *data, uint8_t size,								void *user_data){	const uint8_t *event = data;	const struct bt_hci_evt_le_read_local_pk256_complete *evt;	struct le_keys *keys = user_data;	if (*event != BT_HCI_EVT_LE_READ_LOCAL_PK256_COMPLETE) {		tester_warn("Failed Read Local PK256 command");		tester_test_failed();		return;	}	evt = (void *)(event + 1);	if (evt->status) {		tester_warn("HCI Read Local PK complete failed (0x%02x)",								evt->status);		tester_test_failed();		return;	}	memcpy(keys->local_pk, evt->local_pk256, 64);	util_hexdump('>', evt->local_pk256, 64, test_debug, NULL);	tester_test_passed();}

static void test_getpeername_not_connected(const void *test_data){	struct test_data *data = tester_get_data();	struct sockaddr_l2 addr;	socklen_t len;	int sk;	sk = create_l2cap_sock(data, 0, 0, 0);	if (sk < 0) {		tester_test_failed();		return;	}	len = sizeof(addr);	if (getpeername(sk, (struct sockaddr *) &addr, &len) == 0) {		tester_warn("getpeername succeeded on non-connected socket");		tester_test_failed();		goto done;	}	if (errno != ENOTCONN) {		tester_warn("Unexpexted getpeername error: %s (%d)",						strerror(errno), errno);		tester_test_failed();		goto done;	}	tester_test_passed();done:	close(sk);}

static void test_close_socket_conn_cancel(void){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	if (l2data == &le_client_close_socket_test_2)		tester_test_passed();}

static gboolean l2cap_connect_cb(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	int err, sk_err, sk;	socklen_t len = sizeof(sk_err);	data->io_id = 0;	sk = g_io_channel_unix_get_fd(io);	if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &sk_err, &len) < 0)		err = -errno;	else		err = -sk_err;	if (err < 0)		tester_warn("Connect failed: %s (%d)", strerror(-err), -err);	else		tester_print("Successfully connected");	if (l2data->read_data) {		struct bthost *bthost;		bthost = hciemu_client_get_host(data->hciemu);		g_io_add_watch(io, G_IO_IN, client_received_data, NULL);		bthost_send_cid(bthost, data->handle, data->dcid,					l2data->read_data, l2data->data_len);		return FALSE;	} else if (l2data->write_data) {		struct bthost *bthost;		ssize_t ret;		bthost = hciemu_client_get_host(data->hciemu);		bthost_add_cid_hook(bthost, data->handle, data->dcid,					bthost_received_data, NULL);		ret = write(sk, l2data->write_data, l2data->data_len);		if (ret != l2data->data_len) {			tester_warn("Unable to write all data");			tester_test_failed();		}		return FALSE;	}	if (-err != l2data->expect_err)		tester_test_failed();	else		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_condition_complete(struct test_data *data){	data->unmet_conditions--;	tester_print("Test condition complete, %d left",						data->unmet_conditions);	if (data->unmet_conditions > 0)		return;	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 gboolean test_two_sockets_connect_cb(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	int err, sk_err, sk;	socklen_t len = sizeof(sk_err);	data->io_id = 0;	sk = g_io_channel_unix_get_fd(io);	if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &sk_err, &len) < 0)		err = -errno;	else		err = -sk_err;	if (err < 0) {		tester_warn("Connect failed: %s (%d)", strerror(-err), -err);		tester_test_failed();		return FALSE;	}	tester_print("Successfully connected");	test_two_sockets_connect_cb_cnt++;	if (test_two_sockets_connect_cb_cnt == 2) {		close(data->sk);		close(data->sk2);		tester_test_passed();	}	if (l2data->close_one_socket && test_two_sockets_connect_cb_cnt == 1) {		close(data->sk2);		tester_test_passed();	}	return FALSE;}

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_server_data *l2data = test_data->test_data;	tester_print("Client received response code 0x%02x", code);	if (code != l2data->expect_rsp_code) {		tester_warn("Unexpected L2CAP response code (expected 0x%02x)",						l2data->expect_rsp_code);		goto failed;	}	if (!l2data->expect_rsp) {		tester_test_passed();		return;	}	if (l2data->expect_rsp_len != len) {		tester_warn("Unexpected L2CAP response length (%u != %u)",						len, l2data->expect_rsp_len);		goto failed;	}	if (memcmp(l2data->expect_rsp, data, len) != 0) {		tester_warn("Unexpected L2CAP response");		goto failed;	}	tester_test_passed();	return;failed:	tester_test_failed();}

static void server_bthost_received_data(const void *buf, uint16_t len,							void *user_data){	struct test_data *data = tester_get_data();	const struct l2cap_data *l2data = data->test_data;	if (len != l2data->data_len) {		tester_test_failed();		return;	}	if (memcmp(buf, l2data->write_data, l2data->data_len))		tester_test_failed();	else		tester_test_passed();}

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 gboolean rfcomm_listen_cb(GIOChannel *io, GIOCondition cond,							gpointer user_data){	struct test_data *data = tester_get_data();	const struct rfcomm_server_data *server_data = data->test_data;	int sk, new_sk;	data->io_id = 0;	sk = g_io_channel_unix_get_fd(io);	new_sk = accept(sk, NULL, NULL);	if (new_sk < 0) {		tester_test_failed();		return false;	}	if (server_data->send_data) {		ssize_t ret;		ret = write(new_sk, server_data->send_data,							server_data->data_len);		if (ret != server_data->data_len)			tester_test_failed();		close(new_sk);		return false;	} else if (server_data->read_data) {		GIOChannel *new_io;		new_io = g_io_channel_unix_new(new_sk);		g_io_channel_set_close_on_unref(new_io, TRUE);		data->io_id = g_io_add_watch(new_io, G_IO_IN,						server_received_data, NULL);		g_io_channel_unref(new_io);		return false;	}	close(new_sk);	tester_test_passed();	return false;}

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_reset_in_advertising_state_timeout(void *user_data){	struct user_data *user = tester_get_data();	struct bt_hci_cmd_le_set_adv_enable lsae;	struct bt_hci_cmd_le_set_scan_enable lsse;	lsae.enable = 0x00;	bt_hci_send(user->hci_ut, BT_HCI_CMD_LE_SET_ADV_ENABLE,					&lsae, sizeof(lsae), NULL, NULL, NULL);	lsse.enable = 0x00;	lsse.filter_dup = 0x00;	bt_hci_send(user->hci_lt, BT_HCI_CMD_LE_SET_SCAN_ENABLE,					&lsse, sizeof(lsse), NULL, NULL, NULL);	tester_test_passed();}

static gboolean context_quit(gpointer user_data){	struct context *context = user_data;	if (context->process > 0)		g_source_remove(context->process);	if (context->source > 0)		g_source_remove(context->source);	bt_hog_unref(context->hog);	g_attrib_unref(context->attrib);	g_free(context);	tester_test_passed();	return FALSE;}

static void test_pagesize(const void *data){	char key[18], *str;	int size;	size = getpagesize();	g_assert(size >= 4096);	tester_debug("System uses a page size of %d bytes/n", size);	util_create_pagesize();	sprintf(key, "11:11:11:11:11:11");	str = textfile_get(test_pathname, key);	tester_debug("%s/n", str);	g_assert(str == NULL);	tester_test_passed();}

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_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();}