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

static bool test_str_regtype(struct torture_context *ctx){	torture_assert_str_equal(ctx, str_regtype(1), "REG_SZ", "REG_SZ failed");	torture_assert_str_equal(ctx, str_regtype(4), "REG_DWORD", "REG_DWORD failed");	return true;}

static bool netrlogonsamlogon_w2k_in_check(struct torture_context *tctx,					   struct netr_LogonSamLogon *r){	uint8_t credential_expected[8] = { 0x08, 0xaf, 0x72, 0x50, 0xa0, 0x5b, 0x50, 0x19 };	uint8_t return_authenticator_expected[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };	uint8_t lmpassword_expected[16] = { 0x31, 0xeb, 0xf4, 0x68, 0x62, 0x93, 0xfe, 0x38, 0x51, 0xc1, 0x1d, 0x41, 0x0a, 0xbd, 0x5d, 0xdf };	uint8_t ntpassword_expected[16] = { 0xe3, 0x4f, 0x76, 0x7f, 0x19, 0x12, 0xcd, 0xfe, 0x9c, 0x68, 0xed, 0x9b, 0x1e, 0x9c, 0x66, 0xf6 };	torture_assert_str_equal(tctx, r->in.server_name, "////W2KSRV", "server_name");	torture_assert_str_equal(tctx, r->in.computer_name, "MTHELENA", "computer_name");	torture_assert_mem_equal(tctx, r->in.credential->cred.data, credential_expected, 8, "credential");/*	torture_assert_int_equal(tctx, r->in.credential->timestamp, 0, "credential.timestamp"); */	torture_assert_mem_equal(tctx, r->in.return_authenticator->cred.data, return_authenticator_expected, 8, "return_authenticator.cred.data");	torture_assert_int_equal(tctx, r->in.return_authenticator->timestamp, 0, "return_authenticator.timestamp");	torture_assert_int_equal(tctx, r->in.logon_level, NetlogonInteractiveInformation, "logon_level");	torture_assert(tctx, r->in.logon, "logon NULL pointer");	torture_assert(tctx, r->in.logon->password, "logon->password NULL pointer");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.domain_name.length, 12, "domain_name.length");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.domain_name.size, 12, "domain_name.size");	torture_assert_str_equal(tctx, r->in.logon->password->identity_info.domain_name.string, "W2KDOM", "domain_name.string");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.parameter_control, 0, "parameter_control");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.logon_id_low, 0xdead, "logon_id_low");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.logon_id_high, 0xbeef, "logon_id_high");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.account_name.length, 26, "account_name.length");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.account_name.size, 26, "account_name.size");	torture_assert_str_equal(tctx, r->in.logon->password->identity_info.account_name.string, "administrator", "account_name.string");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.workstation.length, 20, "workstation.length");	torture_assert_int_equal(tctx, r->in.logon->password->identity_info.workstation.size, 20, "workstation.size");	torture_assert_str_equal(tctx, r->in.logon->password->identity_info.workstation.string, "////mthelena", "workstation.string");	torture_assert_mem_equal(tctx, r->in.logon->password->lmpassword.hash, lmpassword_expected, 16, "lmpassword");	torture_assert_mem_equal(tctx, r->in.logon->password->ntpassword.hash, ntpassword_expected, 16, "ntpassword");	torture_assert_int_equal(tctx, r->in.validation_level, 6, "validation_level");	return true;}

static bool witness_AsyncNotify_check_move_OUT(struct torture_context *tctx,					       struct witness_AsyncNotify *r){	struct witness_notifyResponse *n;	struct witness_IPaddrInfoList *i;	torture_assert(tctx, r->out.response, "r->out.response");	n = *(r->out.response);	torture_assert_int_equal(tctx, n->type, WITNESS_NOTIFY_CLIENT_MOVE, "type");	torture_assert_int_equal(tctx, n->length, 36, "length");	torture_assert_int_equal(tctx, n->num, 1, "num");	i = &n->messages[0].client_move;	torture_assert_int_equal(tctx, i->length, 36, "i->length");	torture_assert_int_equal(tctx, i->reserved, 0, "i->reserved");	torture_assert_int_equal(tctx, i->num, 1, "i->num");	torture_assert_int_equal(tctx, i->addr[0].flags, WITNESS_IPADDR_V4, "i->addr[0].flags");	torture_assert_str_equal(tctx, i->addr[0].ipv4, "192.168.3.45", "i->addr[0].ipv4");	torture_assert_str_equal(tctx, i->addr[0].ipv6, "0000:0000:38e8:eb26:8e00:0000:009e:6026", "i->addr[0].ipv6");	return true;}

static bool test_wbc_lookup_rids(struct torture_context *tctx){	struct wbcDomainSid builtin;	uint32_t rids[2] = { 544, 545 };	const char *domain_name, **names;	enum wbcSidType *types;	wbcErr ret;	wbcStringToSid("S-1-5-32", &builtin);	ret = wbcLookupRids(&builtin, 2, rids, &domain_name, &names,			    &types);	torture_assert_wbc_ok(tctx, ret, "wbcLookupRids failed");	torture_assert_str_equal(		tctx, names[0], "Administrators",		"S-1-5-32-544 not mapped to 'Administrators'");	torture_assert_str_equal(		tctx, names[1], "Users", "S-1-5-32-545 not mapped to 'Users'");	wbcFreeMemory(discard_const_p(char ,domain_name));	wbcFreeMemory(names);	wbcFreeMemory(types);	return true;}

static bool witness_GetInterfaceList_check(struct torture_context *tctx,					   struct witness_GetInterfaceList *r){	struct witness_interfaceList *l;	torture_assert(tctx, r->out.interface_list, "r->out.interface_list");	l = *(r->out.interface_list);	torture_assert_int_equal(tctx, l->num_interfaces, 2, "l->num_interfaces");	torture_assert(tctx, l->interfaces, "l->interfaces");	torture_assert_str_equal(tctx, l->interfaces[0].group_name, "NODE2", "l->interfaces[0].group_name");	torture_assert_int_equal(tctx, l->interfaces[0].version, -1, "l->interfaces[0].version");	torture_assert_int_equal(tctx, l->interfaces[0].state, 1, "l->interfaces[0].state");	torture_assert_str_equal(tctx, l->interfaces[0].ipv4, "192.168.3.44", "l->interfaces[0].state");	torture_assert_int_equal(tctx, l->interfaces[0].flags, 5, "l->interfaces[0].flags");	torture_assert_str_equal(tctx, l->interfaces[1].group_name, "NODE1", "l->interfaces[0].group_name");	torture_assert_int_equal(tctx, l->interfaces[1].version, -1, "l->interfaces[0].version");	torture_assert_int_equal(tctx, l->interfaces[1].state, 1, "l->interfaces[0].state");	torture_assert_str_equal(tctx, l->interfaces[1].ipv4, "192.168.3.45", "l->interfaces[0].state");	torture_assert_int_equal(tctx, l->interfaces[1].flags, 1, "l->interfaces[0].flags");	torture_assert_werr_ok(tctx, r->out.result, "r->out.result");	return true;}

static bool test_rpc_netservergetinfo(struct torture_context *tctx,				      struct smbcli_state *cli){	struct rap_WserverGetInfo r;	struct dcerpc_pipe *p;	struct dcerpc_binding_handle *b;	struct srvsvc_NetSrvGetInfo s;	union srvsvc_NetSrvInfo info;	const char *server_name;	torture_assert_ntstatus_ok(tctx,		torture_rpc_connection(tctx, &p, &ndr_table_srvsvc),		"failed to open srvsvc");	b = p->binding_handle;	s.in.server_unc = NULL;	s.in.level = 101;	s.out.info = &info;	torture_assert_ntstatus_ok(tctx,		dcerpc_srvsvc_NetSrvGetInfo_r(b, tctx, &s),		"srvsvc_NetSrvGetInfo level 101 failed");	torture_assert_werr_ok(tctx, s.out.result,		"srvsvc_NetSrvGetInfo level 101 failed");	r.in.bufsize = 0xffff;	r.in.level = 0;	torture_assert_ntstatus_ok(tctx,		smbcli_rap_netservergetinfo(cli->tree, tctx, &r),		"rap_netservergetinfo level 0 failed");	torture_assert_int_equal(tctx, r.out.status, 0,		"rap_netservergetinfo level 0 failed");	server_name = talloc_strndup(tctx, info.info101->server_name, 16);	torture_assert_str_equal(tctx, (const char *)r.out.info.info0.name, server_name, "server name");	r.in.level = 1;	torture_assert_ntstatus_ok(tctx,		smbcli_rap_netservergetinfo(cli->tree, tctx, &r),		"rap_netservergetinfo level 1 failed");	torture_assert_int_equal(tctx, r.out.status, 0,		"rap_netservergetinfo level 1 failed");	torture_assert_str_equal(tctx, (const char *)r.out.info.info1.name, server_name, "server name");	torture_assert_int_equal(tctx, r.out.info.info1.version_major, info.info101->version_major, "version major");	torture_assert_int_equal(tctx, r.out.info.info1.version_minor, info.info101->version_minor, "version minor");	torture_assert_int_equal(tctx, r.out.info.info1.servertype, info.info101->server_type, "server_type");	torture_assert_str_equal(tctx, r.out.info.info1.comment, info.info101->comment, "comment");	talloc_free(p);	return true;}

static bool test_reg_val_data_string_sz(struct torture_context *ctx){	DATA_BLOB db;	db.length = convert_string_talloc(ctx, CH_UNIX, CH_UTF16, "bla", 3, (void **)&db.data);	torture_assert_str_equal(ctx, "bla", reg_val_data_string(ctx, REG_SZ, &db), "sz failed");	db.length = 4;	torture_assert_str_equal(ctx, "bl", reg_val_data_string(ctx, REG_SZ, &db), "sz failed");	return true;}

static bool test_talloc_ptrtype(const struct torture_context *ctx){	void *top = talloc_new(ctx);	struct struct1 {		int foo;		int bar;	} *s1, *s2, **s3, ***s4;	const char *location1;	const char *location2;	const char *location3;	const char *location4;	bool ret = false;	if (!top)		goto out;	s1 = talloc_ptrtype(top, s1);location1 = __location__;	if (!s1)		goto out;	ok1(talloc_get_size(s1) == sizeof(struct struct1));	ok1(strcmp(location1, talloc_get_name(s1)) == 0);	s2 = talloc_array_ptrtype(top, s2, 10);location2 = __location__;	if (!s2)		goto out;	ok1(talloc_get_size(s2) == (sizeof(struct struct1) * 10));	ok1(strcmp(location2, talloc_get_name(s2)) == 0);	s3 = talloc_array_ptrtype(top, s3, 10);location3 = __location__;	if (!s3)		goto out;	ok1(talloc_get_size(s3) == (sizeof(struct struct1 *) * 10));	torture_assert_str_equal("ptrtype", location3, talloc_get_name(s3),		"talloc_array_ptrtype() sets the wrong name");	s4 = talloc_array_ptrtype(top, s4, 10);location4 = __location__;	if (!s4)		goto out;	ok1(talloc_get_size(s4) == (sizeof(struct struct1 **) * 10));	torture_assert_str_equal("ptrtype", location4, talloc_get_name(s4),		"talloc_array_ptrtype() sets the wrong name");	ret = true;out:	talloc_free(top);	return ret;}

static bool netrserverreqchallenge_in_check(struct torture_context *tctx,					    struct netr_ServerReqChallenge *r){	uint8_t cred_expected[8] = { 0xa3, 0x2c, 0xa2, 0x95, 0x40, 0xcc, 0xb7, 0xbb };	torture_assert_str_equal(tctx, r->in.server_name, "////NATIVE-DC.NATIVE.BASE", "server name");	torture_assert_str_equal(tctx, r->in.computer_name, "NATIVE-2K", "account name");	torture_assert_mem_equal(tctx, cred_expected, r->in.credentials->data, 8, "credentials");	return true;}

static bool witness_Register_check_IN(struct torture_context *tctx,				      struct witness_Register *r){	torture_assert_int_equal(tctx, r->in.version, 65537, "r->in.version");	torture_assert_str_equal(tctx, r->in.net_name, "sofs", "r->in.net_name");	torture_assert_str_equal(tctx, r->in.ip_address, "192.168.3.45", "r->in.ip_address");	torture_assert_str_equal(tctx, r->in.client_computer_name, "MTHELENA", "r->in.client_computer_name");	return true;}

static bool test_next_token_quote_wrong(struct torture_context *tctx){	const char *teststr = "/"foo bar bla";	char buf[20];	torture_assert(tctx, next_token(&teststr, buf, " ", 20), "finding token works");	torture_assert_str_equal(tctx, buf, "foo bar bla", "token matches");	torture_assert_str_equal(tctx, teststr, "", "ptr modified correctly");	torture_assert(tctx, !next_token(&teststr, buf, " ", 20), "finding token doesn't work");	return true;}

static bool jobadd_in_check(struct torture_context *tctx, 							 struct atsvc_JobAdd *r){	torture_assert_str_equal(tctx, r->in.servername, "WIN2KDC1", "servername");	torture_assert_int_equal(tctx, r->in.job_info->job_time, 84600000, "time");	torture_assert_int_equal(tctx, r->in.job_info->days_of_month, 0, "days of month");	torture_assert_int_equal(tctx, r->in.job_info->days_of_week, 0x2, "days of week");	torture_assert_int_equal(tctx, r->in.job_info->flags, 17, "flags");	torture_assert_str_equal(tctx, r->in.job_info->command, "foo.exe", "command");	return true;}

static bool netrserverauthenticate3_in_check(struct torture_context *tctx,											struct netr_ServerAuthenticate3 *r){	uint8_t cred_expected[8] = { 0x68, 0x8e, 0x3c, 0xdf, 0x23, 0x02, 0xb1, 0x51 };	torture_assert_str_equal(tctx, r->in.server_name, "////NATIVE-DC.NATIVE.BASE", "server name");	torture_assert_str_equal(tctx, r->in.account_name, "NATIVE-2K$", "account name");	torture_assert_int_equal(tctx, r->in.secure_channel_type, 2, "secure channel type");	torture_assert_str_equal(tctx, r->in.computer_name, "NATIVE-2K", "computer name");	torture_assert_int_equal(tctx, *r->in.negotiate_flags, 0x6007ffff, "negotiate flags");	torture_assert_mem_equal(tctx, cred_expected, r->in.credentials->data, 8, "credentials");	return true;}

static bool netlogon_logon_request_req_check(struct torture_context *tctx,					     struct nbt_netlogon_packet *r){	torture_assert_int_equal(tctx, r->command, LOGON_REQUEST, "command");	torture_assert_str_equal(tctx, r->req.logon0.computer_name, "WIN98", "computer name");	torture_assert_str_equal(tctx, r->req.logon0.user_name, "GD", "user_name");	torture_assert_str_equal(tctx, r->req.logon0.mailslot_name, "//MAILSLOT//TEMP//NETLOGON", "mailslot_name");	torture_assert_int_equal(tctx, r->req.logon0.request_count, 1, "request_count");	torture_assert_int_equal(tctx, r->req.logon0.lmnt_token, 1, "lmnt_token");	torture_assert_int_equal(tctx, r->req.logon0.lm20_token, 0xffff, "lm20_token");	return true;}

static bool netlogon_samlogon_response_check(struct torture_context *tctx,					     struct netlogon_samlogon_response *r){	struct GUID guid;	torture_assert_ntstatus_ok(tctx, GUID_from_string("cd441303-001c-464c-a621-e9d6b9b12fe9", &guid), "");	torture_assert_int_equal(tctx, r->ntver, 5, "ntver");	torture_assert_int_equal(tctx, r->data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX, "command");	torture_assert_int_equal(tctx, r->data.nt5_ex.sbz, 0, "sbz");	torture_assert_int_equal(tctx, r->data.nt5_ex.server_type, 0x000033fd, "server_type");	torture_assert_guid_equal(tctx, r->data.nt5_ex.domain_uuid, guid, "domain_uuid");	torture_assert_str_equal(tctx, r->data.nt5_ex.forest, "w2k8dom.ber.redhat.com", "forest");	torture_assert_str_equal(tctx, r->data.nt5_ex.dns_domain, "w2k8dom.ber.redhat.com", "dns_domain");	torture_assert_str_equal(tctx, r->data.nt5_ex.pdc_dns_name, "gdw2k8r2.w2k8dom.ber.redhat.com", "pdc_dns_name");	torture_assert_str_equal(tctx, r->data.nt5_ex.domain_name, "W2K8DOM", "domain_name");	torture_assert_str_equal(tctx, r->data.nt5_ex.pdc_name, "GDW2K8R2", "pdc_name");	torture_assert_str_equal(tctx, r->data.nt5_ex.user_name, "", "user_name");	torture_assert_str_equal(tctx, r->data.nt5_ex.server_site, "Default-First-Site-Name", "server_site");	torture_assert_str_equal(tctx, r->data.nt5_ex.client_site, "Default-First-Site-Name", "client_site");	torture_assert_int_equal(tctx, r->data.nt5_ex.sockaddr_size, 0, "sockaddr_size");	/* sockaddr: struct nbt_sockaddr	 *             sockaddr_family          : 0x00000000 (0)	 *             pdc_ip                   : (null)	 *             remaining                : DATA_BLOB length=0 */	torture_assert_int_equal(tctx, r->data.nt5_ex.nt_version, 5, "nt_version");	/* next_closest_site NULL */	torture_assert_int_equal(tctx, r->data.nt5_ex.lmnt_token, 0xffff, "lmnt_token");	torture_assert_int_equal(tctx, r->data.nt5_ex.lm20_token, 0xffff, "lm20_token");	return true;}

static bool netlogon_samlogon_response_check2(struct torture_context *tctx,					      struct netlogon_samlogon_response *r){	struct GUID guid;	torture_assert_ntstatus_ok(tctx, GUID_from_string("138daf55-918c-4170-9d46-d4d50490aa13", &guid), "");	torture_assert_int_equal(tctx, r->ntver, 5, "ntver");	torture_assert_int_equal(tctx, r->data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX, "command");	torture_assert_int_equal(tctx, r->data.nt5_ex.sbz, 0, "sbz");	torture_assert_int_equal(tctx, r->data.nt5_ex.server_type, 0x000033fd, "server_type");	torture_assert_guid_equal(tctx, r->data.nt5_ex.domain_uuid, guid, "domain_uuid");	torture_assert_str_equal(tctx, r->data.nt5_ex.forest, "bla.base", "forest");	torture_assert_str_equal(tctx, r->data.nt5_ex.dns_domain, "bla.base", "dns_domain");	torture_assert_str_equal(tctx, r->data.nt5_ex.pdc_dns_name, "W2K8R2-219.bla.base", "pdc_dns_name");	torture_assert_str_equal(tctx, r->data.nt5_ex.domain_name, "BLA", "domain_name");	torture_assert_str_equal(tctx, r->data.nt5_ex.pdc_name, "W2K8R2-219", "pdc_name");	torture_assert_str_equal(tctx, r->data.nt5_ex.user_name, "w2012r2-l6.base.", "user_name");	torture_assert_str_equal(tctx, r->data.nt5_ex.server_site, "Default-First-Site-Name", "server_site");	torture_assert_str_equal(tctx, r->data.nt5_ex.client_site, "Default-First-Site-Name", "client_site");	torture_assert_int_equal(tctx, r->data.nt5_ex.sockaddr_size, 0, "sockaddr_size");	/*	 * sockaddr: struct nbt_sockaddr	 *             sockaddr_family          : 0x00000000 (0)	 *             pdc_ip                   : (null)	 *             remaining                : DATA_BLOB length=0	 */	torture_assert_int_equal(tctx, r->data.nt5_ex.nt_version, 5, "nt_version");	/* next_closest_site NULL */	torture_assert_int_equal(tctx, r->data.nt5_ex.lmnt_token, 0xffff, "lmnt_token");	torture_assert_int_equal(tctx, r->data.nt5_ex.lm20_token, 0xffff, "lm20_token");	return true;}

static bool torture_winbind_struct_check_machacc(struct torture_context *torture){	bool ok;	bool strict = torture_setting_bool(torture, "strict mode", false);	struct winbindd_response rep;	ZERO_STRUCT(rep);	torture_comment(torture, "Running WINBINDD_CHECK_MACHACC (struct based)/n");	ok = true;	DO_STRUCT_REQ_REP_EXT(WINBINDD_CHECK_MACHACC, NULL, &rep,			      NSS_STATUS_SUCCESS, strict, ok = false,			      "WINBINDD_CHECK_MACHACC");	if (!ok) {		torture_assert(torture,			       strlen(rep.data.auth.nt_status_string)>0,			       "Failed with empty nt_status_string");		torture_warning(torture,"%s:%s:%s:%d/n",				nt_errstr(NT_STATUS(rep.data.auth.nt_status)),				rep.data.auth.nt_status_string,				rep.data.auth.error_string,				rep.data.auth.pam_error);		return true;	}	torture_assert_ntstatus_ok(torture,				   NT_STATUS(rep.data.auth.nt_status),				   "WINBINDD_CHECK_MACHACC ok: nt_status");	torture_assert_str_equal(torture,				 rep.data.auth.nt_status_string,				 nt_errstr(NT_STATUS_OK),				 "WINBINDD_CHECK_MACHACC ok:nt_status_string");	torture_assert_str_equal(torture,				 rep.data.auth.error_string,				 get_friendly_nt_error_msg(NT_STATUS_OK),				 "WINBINDD_CHECK_MACHACC ok: error_string");	torture_assert_int_equal(torture,				 rep.data.auth.pam_error,				 nt_status_to_pam(NT_STATUS_OK),				 "WINBINDD_CHECK_MACHACC ok: pam_error");	return true;}

static bool test_socket_wrapper_dir(struct torture_context *tctx){	backup_env();	setenv("SOCKET_WRAPPER_DIR", "foo", 1);	torture_assert_str_equal(tctx, socket_wrapper_dir(), "foo", "setting failed");	setenv("SOCKET_WRAPPER_DIR", "./foo", 1);	torture_assert_str_equal(tctx, socket_wrapper_dir(), "foo", "setting failed");	unsetenv("SOCKET_WRAPPER_DIR");	torture_assert_str_equal(tctx, socket_wrapper_dir(), NULL, "resetting failed");	restore_env();	return true;}

static bool test_init_anonymous(struct torture_context *tctx){	struct cli_credentials *creds = cli_credentials_init_anon(tctx);	torture_assert_str_equal(tctx, cli_credentials_get_domain(creds),				 "", "domain");	torture_assert_str_equal(tctx, cli_credentials_get_username(creds),				 "", "username");	torture_assert(tctx, cli_credentials_get_password(creds) == NULL,				 "password");	return true;}

static bool nbt_netlogon_packet_logon_primary_query_check(struct torture_context *tctx,							  struct nbt_netlogon_packet *r){	torture_assert_int_equal(tctx, r->command, LOGON_PRIMARY_QUERY, "command");	torture_assert_str_equal(tctx, r->req.pdc.computer_name, "XPDATEV-PRO", "computer_name");	torture_assert_str_equal(tctx, r->req.pdc.mailslot_name, "//MAILSLOT//NET//GETDC817", "mailslot_name");	torture_assert_int_equal(tctx, r->req.pdc._pad.length, 1, "_pad.length");	torture_assert_int_equal(tctx, r->req.pdc._pad.data[0], 0, "_pad.data");	torture_assert_str_equal(tctx, r->req.pdc.unicode_name, "XPDATEV-PRO", "unicode_name");	torture_assert_int_equal(tctx, r->req.pdc.nt_version, 0x0000000b, "nt_version");	torture_assert_int_equal(tctx, r->req.pdc.lmnt_token, 0xffff, "lmnt_token");	torture_assert_int_equal(tctx, r->req.pdc.lm20_token, 0xffff, "lm20_token");	return true;}

static bool alpha13_supplementalCredentials_check(struct torture_context *tctx,						  struct supplementalCredentialsBlob *r){	torture_assert_int_equal(tctx, r->unknown1, 0, "unknown1");	torture_assert_int_equal(tctx, r->__ndr_size, 0x5F8, "__ndr_size");	torture_assert_int_equal(tctx, r->unknown2, 0, "unknown2");	torture_assert_str_equal(tctx, r->sub.prefix, SUPPLEMENTAL_CREDENTIALS_PREFIX, "prefix");	torture_assert_int_equal(tctx, r->sub.signature, SUPPLEMENTAL_CREDENTIALS_SIGNATURE, "signature");	torture_assert_int_equal(tctx, r->sub.num_packages, 3, "num_packages");	torture_assert_str_equal(tctx, r->sub.packages[0].name, "Primary:Kerberos", "name of package 0");	torture_assert_str_equal(tctx, r->sub.packages[1].name, "Packages", "name of package 1");	torture_assert_str_equal(tctx, r->sub.packages[2].name, "Primary:WDigest", "name of package 2");	torture_assert_int_equal(tctx, r->unknown3, 0x00, "unknown3"); /* This is typically not initialized */	return true;}

static bool test_provision(struct torture_context *tctx){	NTSTATUS status;	struct provision_settings *settings = talloc_zero(tctx, struct provision_settings);	struct provision_result result;	char *targetdir = NULL;	torture_assert_ntstatus_ok(tctx, torture_temp_dir(tctx, "torture_provision", &targetdir), 				   "torture_temp_dir should return NT_STATUS_OK" );	settings->targetdir = talloc_steal(settings, targetdir);	settings->site_name = "SOME-SITE-NAME";	settings->root_dn_str = "DC=EXAMPLE,DC=COM";	settings->domain_dn_str = "DC=EXAMPLE,DC=COM";	settings->config_dn_str = NULL;	settings->schema_dn_str = NULL;	settings->invocation_id = NULL;	settings->netbios_name = "FOO";	settings->realm = "EXAMPLE.COM";	settings->domain = "EXAMPLE";	settings->netbios_name = "torture";	settings->ntds_dn_str = NULL;	settings->machine_password = "geheim";	status = provision_bare(settings, tctx->lp_ctx, settings, &result);				torture_assert_ntstatus_ok(tctx, status, "provision");	torture_assert_str_equal(tctx, result.domaindn, "DC=EXAMPLE,DC=COM", 				 "domaindn incorrect");	return true;}

static bool test_reg_val_data_string_binary(struct torture_context *ctx){	uint8_t x[] = { 0x1, 0x2, 0x3, 0x4 };	DATA_BLOB db = { x, 4 };	torture_assert_str_equal(ctx, "01020304", reg_val_data_string(ctx, REG_BINARY, &db), "binary failed");	return true;}

static bool test_reg_val_data_string_dword(struct torture_context *ctx){	uint32_t d = 0x20;	DATA_BLOB db = { (uint8_t *)&d, sizeof(d) };	torture_assert_str_equal(ctx, "0x20", reg_val_data_string(ctx, REG_DWORD, &db), "dword failed");	return true;}

static bool jobgetinfo_in_check(struct torture_context *tctx, 								struct atsvc_JobGetInfo *r){	torture_assert_str_equal(tctx, r->in.servername, "WIN2KDC1", "servername");	torture_assert_int_equal(tctx, r->in.job_id, 1, "job id");	return true;}

static bool test_set_option(struct torture_context *tctx){	struct loadparm_context *lp_ctx = loadparm_init(tctx);	torture_assert(tctx, lpcfg_set_option(lp_ctx, "workgroup=werkgroep"), "lpcfg_set_option failed");	torture_assert_str_equal(tctx, "WERKGROEP", lpcfg_workgroup(lp_ctx), "workgroup");	return true;}

static bool ntprinting_printer_latin1_check(struct torture_context *tctx){	enum ndr_err_code ndr_err;	struct ntprinting_printer r;	DATA_BLOB blob;	bool ok;	ok = lpcfg_do_global_parameter(tctx->lp_ctx, "dos charset", "CP1252");	if (!ok) {		torture_comment(tctx, "Could not set 'dos charset' option./n");		return false;	}	reload_charcnv(tctx->lp_ctx);	ZERO_STRUCT(r);	r.info.string_flags = LIBNDR_FLAG_STR_ASCII;	blob = data_blob_const(ntprinting_printer_data_latin1,			       sizeof(ntprinting_printer_data_latin1));	ndr_err = ndr_pull_struct_blob(&blob, tctx, &r,		   (ndr_pull_flags_fn_t)ndr_pull_ntprinting_printer);	torture_assert_ndr_success(tctx,				   ndr_err,				   "ndr_pull_ntprinting_printer");#if 0	ndr_print_debug((ndr_print_fn_t) ndr_print_ntprinting_printer,			"ntprinter",			&r);#endif	torture_assert_str_equal(tctx,				 r.info.printername,				 "S0BC",				 "printername");	/* latin1 encoding check */	torture_assert_str_equal(tctx,				 r.info.comment,				 "/" SALA DA RECEP
C++ torture_comment函数代码示例
C++ torture_assert_int_equal函数代码示例