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

BOOL CFileVersionInfo::QueryStringValue( IN  LPCTSTR lpszItem,										 OUT LPTSTR  lpszValue, 										 IN  INT     nBuf ) const{	if( m_bValid  == FALSE || lpszItem == NULL )		ASSERT_RETURN( FALSE );		if( lpszValue != NULL && nBuf <= 0 )		ASSERT_RETURN( FALSE );	::ZeroMemory( lpszValue, nBuf * sizeof( TCHAR ) );	TCHAR szSFI[ MAX_PATH ] = { 0 };	::wsprintf( szSFI, _T( "//StringFileInfo//%04X%04X//%s" ), 		GetCurLID(), GetCurCP(), lpszItem );	BOOL   bRes    = FALSE;	UINT   uLen    = 0;	LPTSTR lpszBuf = NULL;	if( ::VerQueryValue( m_lpbyVIB, (LPTSTR)szSFI, (LPVOID*)&lpszBuf, &uLen ) )	{		if( lpszValue != NULL && nBuf > 0 )			bRes = (BOOL)( ::lstrcpyn( lpszValue, lpszBuf, nBuf ) != NULL );		else			bRes = TRUE;	}		return ( bRes );}

int kdbus_test_sync_reply(struct kdbus_test_env *env){	pthread_t thread;	int ret;	conn_a = kdbus_hello(env->buspath, 0, NULL, 0);	conn_b = kdbus_hello(env->buspath, 0, NULL, 0);	ASSERT_RETURN(conn_a && conn_b);	pthread_create(&thread, NULL, run_thread, NULL);	ret = kdbus_msg_send(conn_b, NULL, cookie,			     KDBUS_MSG_FLAGS_EXPECT_REPLY |			     KDBUS_MSG_FLAGS_SYNC_REPLY,			     5000000000ULL, 0, conn_a->id);	pthread_join(thread, NULL);	ASSERT_RETURN(ret == 0);	kdbus_printf("-- closing bus connections/n");	kdbus_conn_free(conn_a);	kdbus_conn_free(conn_b);	return TEST_OK;}

	bool KBagManager::AddOneCell( const SC_BagAddResponse* pBAR )	{		ASSERT_RETURN(pBAR, false);		int nBagID = pBAR->byteBagID;		KBag* pBag = FindBag(nBagID);		ASSERT_RETURN(pBag, false);				KItem item;		item.Clear();		KMsgInputStream si(pBAR->GetItemBuffer(), pBAR->nItemBufferSize);		if(!item.Unserilize(si))		{			return false;		}		if(!pBag->AddOneCell(pBAR->nPos, item))		{			return false;		}				pBag->NumChange(item.GetID(), item.GetStackNumber());		// 通知界面		int nBoxID = BagId2BoxID(nBagID);		ASSERT_RETURN(-1 != nBoxID, false);		KItemBlock* pIB = KItemBlock::Alloc();		pIB->SetPos(nBoxID, pBAR->nPos);		KBlockBoxManager::Instance()->PutBlock(nBoxID, pBAR->nPos, pIB);		if (nBagID == enum_item_BagNormal)		{			KDynamicWorld::getSingleton().SendWorldMsg(LOGIC_WORLD_NORMAL_BAG_ITEM_CHANGE, item.GetID(), 0);		}		return true;	}

	bool KBagManager::IsValidCell( int nBoxId, int nPos ) const	{		int nBagId = BoxID2BagID(nBoxId);		ASSERT_RETURN(nBagId >= enum_item_Bag_Start, false);		const KBag* pBag = FindBag(nBagId);		ASSERT_RETURN(pBag, false);		return pBag->IsPosValid(nPos);	}

int kdbus_test_fd_passing(struct kdbus_test_env *env){	struct kdbus_conn *conn_src, *conn_dst;	const char *str = "stackenblocken";	const struct kdbus_item *item;	struct kdbus_msg *msg;	unsigned int i;	int fds[2];	int ret;	/* create two connections */	conn_src = kdbus_hello(env->buspath, 0, NULL, 0);	conn_dst = kdbus_hello(env->buspath, 0, NULL, 0);	ASSERT_RETURN(conn_src && conn_dst);	/*	 * Try to ass the handle of a connection as message payload.	 * This must fail.	 */	ret = send_fd(conn_src, conn_dst->id, conn_src->fd);	ASSERT_RETURN(ret == -ELOOP);	ret = send_fd(conn_src, conn_dst->id, conn_dst->fd);	ASSERT_RETURN(ret == -ELOOP);	ret = pipe(fds);	ASSERT_RETURN(ret == 0);	i = write(fds[1], str, strlen(str));	ASSERT_RETURN(i == strlen(str));	ret = send_fd(conn_src, conn_dst->id, fds[0]);	ASSERT_RETURN(ret == 0);	ret = kdbus_msg_recv(conn_dst, &msg);	ASSERT_RETURN(ret == 0);	KDBUS_ITEM_FOREACH(item, msg, items) {		if (item->type == KDBUS_ITEM_FDS) {			char tmp[14];			int nfds = (item->size - KDBUS_ITEM_HEADER_SIZE) /					sizeof(int);			ASSERT_RETURN(nfds == 1);			i = read(item->fds[0], tmp, sizeof(tmp));			ASSERT_RETURN(i == sizeof(tmp));			ASSERT_RETURN(memcmp(tmp, str, sizeof(tmp)) == 0);			close(item->fds[0]);			break;		}	}	return TEST_OK;}

	bool KL2Map_Base::_InsertJointToBlock(const _Node_Lite * pNode)	{	PERF_COUNTER(KL2Map_Base__InsertJointToBlock);		ASSERT_RETURN(pNode, false);		int_r bx(-1), by(-1);		GetJointBlockPos(pNode->x, pNode->y, bx, by);		ASSERT_RETURN(bx >= 0, false);		ASSERT_RETURN(by >= 0, false);		return m_L2MapByBlock[bx][by].insert_unique(pNode) > -1;	}

static int unpriv_test_custom_ep(const char *buspath){	int ret, ep_fd1, ep_fd2;	char *ep1, *ep2, *tmp1, *tmp2;	tmp1 = strdup(buspath);	tmp2 = strdup(buspath);	ASSERT_RETURN(tmp1 && tmp2);	ret = asprintf(&ep1, "%s/%u-%s", dirname(tmp1), getuid(), "apps1");	ASSERT_RETURN(ret >= 0);	ret = asprintf(&ep2, "%s/%u-%s", dirname(tmp2), getuid(), "apps2");	ASSERT_RETURN(ret >= 0);	free(tmp1);	free(tmp2);	/* endpoint only accessible to current uid */	ep_fd1 = create_endpoint(buspath, getuid(), "apps1", 0);	ASSERT_RETURN(ep_fd1 >= 0);	/* endpoint world accessible */	ep_fd2 = create_endpoint(buspath, getuid(), "apps2",				  KDBUS_MAKE_ACCESS_WORLD);	ASSERT_RETURN(ep_fd2 >= 0);	ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_UID, ({		int ep_fd;		struct kdbus_conn *ep_conn;		/*		 * Make sure that we are not able to create custom		 * endpoints		 */		ep_fd = create_endpoint(buspath, getuid(),					"unpriv_costum_ep", 0);		ASSERT_EXIT(ep_fd == -EPERM);		/*		 * Endpoint "apps1" only accessible to same users,		 * that own the endpoint. Access denied by VFS		 */		ep_conn = kdbus_hello(ep1, 0, NULL, 0);		ASSERT_EXIT(!ep_conn && errno == EACCES);		/* Endpoint "apps2" world accessible */		ep_conn = kdbus_hello(ep2, 0, NULL, 0);		ASSERT_EXIT(ep_conn);		kdbus_conn_free(ep_conn);		_exit(EXIT_SUCCESS);	}),

static int kdbus_match_kdbus_pids(struct kdbus_msg *msg,				  const struct kdbus_pids *expected_pids){	struct kdbus_item *item;	item = kdbus_get_item(msg, KDBUS_ITEM_PIDS);	ASSERT_RETURN(item);	ASSERT_RETURN(memcmp(&item->pids, expected_pids,			     sizeof(struct kdbus_pids)) == 0);	return 0;}

std::vector<std::wstring> NppInterface::GetOpenFilenames(ViewTarget viewTarget) const {	int enumVal = -1;	switch (viewTarget) {	case ViewTarget::primary:		enumVal = PRIMARY_VIEW;		break;	case ViewTarget::secondary:		enumVal = SECOND_VIEW;		break;	case ViewTarget::both:		enumVal = ALL_OPEN_FILES;		break;	}	ASSERT_RETURN(enumVal >= 0, {});	int count = SendMsgToNpp(NPPM_GETNBOPENFILES, 0, enumVal);	wchar_t** paths;	paths = new wchar_t *[count];	for (int i = 0; i < count; ++i)		paths[i] = new wchar_t[MAX_PATH];	int msg = -1;	switch (viewTarget) {	case ViewTarget::primary:		msg = NPPM_GETOPENFILENAMESPRIMARY;		break;	case ViewTarget::secondary:		msg = NPPM_GETOPENFILENAMESSECOND;		break;	case ViewTarget::both:		msg = NPPM_GETOPENFILENAMES;		break;	}	ASSERT_RETURN(msg >= 0, {}); {		auto ret = SendMsgToNpp(msg, reinterpret_cast<WPARAM>(paths), count);		ASSERT_RETURN(ret == count, {});	}	std::vector<std::wstring> res;	for (int i = 0; i < count; ++i) {		res.push_back(paths[i]);		delete[] paths[i];	}	delete[] paths;	return res;}

	const KCreateInfo_ItemBase* KBagManager::GetOneItemCreateInfoBase( int nBagID, DWORD dwItemID )	{		const KBag* pBag = FindBag(nBagID);		ASSERT_RETURN(pBag, NULL);		int nPos = pBag->GetFirstPos(dwItemID);		ASSERT_RETURN(nPos >= 0, NULL);				const KCellBag* pCell = pBag->FindCell(nPos);		ASSERT_RETURN(pCell, NULL);		const KItem& item = pCell->GetItem();		ASSERT_I(item.GetID() == dwItemID);		return GetItemCreateInfo(dwItemID);	}

	bool KStoreProduct::AddProductPrice(int nMoneyType, int nTParam1, int nTParam2)	{		ASSERT_RETURN(nMoneyType > enumPT_none && nMoneyType < enumPT_count, false);		KStoreProductPrice price;		price.nMoneyType = nMoneyType;		price.nTParam1 = nTParam1;		price.nTParam2 = nTParam2;		int i = 0;		for(i=0;i<sizeof(m_Prices)/sizeof(m_Prices[0]);i++)		{			if(enumPT_none == m_Prices[i].nMoneyType) break;			if(m_Prices[i].nMoneyType == nMoneyType) return false;		}		if(i < PRICE_TYPE_MAX)		{			m_Prices[i].nMoneyType = nMoneyType;			m_Prices[i].nTParam1 = nTParam1;			m_Prices[i].nTParam2 = nTParam2;			return true;		}		return false;	}

void CGraphicWindowChildFrame::moveForward(){	ASSERT_RETURN( forwardTabCount() > 0 );	int newTab = m_forwardTabList[forwardTabCount()];	m_forwardTabList.remove(forwardTabCount());	SetTab( newTab );}

	int KBagManager::GetCount(int nBagID, int nPos) const	{		const KCellBag* pCell = FindCell(nBagID, nPos);		ASSERT_RETURN(pCell, 0);		return pCell->GetItemStackNumber();	}

Enlil_IPTC_Job *enlil_iptc_job_prepend(Enlil_Photo       *photo,                       Enlil_IPTC_Done_Cb cb,                       void              *data){   ASSERT_RETURN(photo != NULL);   Eina_List *l;   Enlil_IPTC_Job *job;   EINA_LIST_FOREACH(l_jobs, l, job)     if(job->photo == photo)       break;   if(!job)     {        job = calloc(1, sizeof(Enlil_IPTC_Job));        job->photo = photo;        job->cb = cb;        job->data = data;     }   else     l_jobs = eina_list_remove(l_jobs, job);   l_jobs = eina_list_prepend(l_jobs, job);   _job_next();   return job;}

MemoryPool* initPool(size_t size, size_t increment){	MemoryPool *pool;	MemoryBlock *block;	void *buffer;	ASSERT_RETURN(size >= sizeof(MemoryPool)+sizeof(MemoryBlock), NULL);	buffer=malloc(size+sizeof(*pool)+sizeof(*block));	if (!buffer)		return NULL;	// Initialize first memory block	block = (MemoryBlock*) ((size_t)buffer+sizeof(*pool));	block->next = NULL;	block->start=(void*)((size_t)block+sizeof(*block));	block->pos=ALIGN_PTR(block->start, POOL_ALIGNMENT);	block->end=block->start+size;	// Initialize pool	pool = (MemoryPool*) buffer;	pool->lastAlloc = 0;	pool->capacity = size;	pool->increment = (increment) ? increment : (size_t)sysconf(_SC_PAGESIZE);	pool->base=block;	pool->cur=block;	PRINT("Pool created, used size=%ld, capacity=%ld, increment size=%ld", (((size_t)(pool->cur->start)) - (size_t)pool), pool->capacity, pool->increment);	return pool;}

intenlil_tag_photos_count_get(const Enlil_Tag *tag){   ASSERT_RETURN(tag != NULL);   return eina_list_count(tag->photos);}

bool SocketAddress::setIntern(Exception& ex,const string& hostAndPort,bool resolveHost) {	ASSERT_RETURN(!hostAndPort.empty(),false);	string host, port;	auto it  = hostAndPort.begin();	auto& end = hostAndPort.end();	if (*it == '[') {		++it;		while (it != end && *it != ']')			host += *it++;		if (it == end) {			ex.set(Exception::NETADDRESS,"Malformed IPv6 address ", hostAndPort);			return false;		}		++it;	} else {		while (it != end && *it != ':')			host += *it++;	}	if (it != end && *it == ':') {		++it;		while (it != end)			port += *it++;	}	else {		ex.set(Exception::NETADDRESS, "Missing port number in ", hostAndPort);		return false;	}	return setIntern(ex,host, resolveService(ex,port),resolveHost);}

int pthread_attr_setinheritsched(pthread_attr_t *attr, int h){  ASSERT_RETURN(!attr,EINVAL);  attr->schedinherited = h;  return 0;}

/* * Return: TEST_OK, TEST_ERR or TEST_SKIP * we return TEST_OK only if the children return with the expected * 'expected_status' that is specified as an argument. */static int kdbus_fork_test(const char *bus, const char *name,			   struct kdbus_conn **conn_db, int expected_status){	pid_t pid;	int ret = 0;	int status = 0;	pid = fork();	ASSERT_RETURN_VAL(pid >= 0, pid);	if (pid == 0) {		ret = prctl(PR_SET_PDEATHSIG, SIGKILL);		ASSERT_EXIT(ret == 0);		ret = drop_privileges(65534, 65534);		ASSERT_EXIT(ret == 0);		ret = kdbus_recv_in_threads(bus, name, conn_db);		_exit(ret == expected_status ? EXIT_SUCCESS : EXIT_FAILURE);	}	ret = waitpid(pid, &status, 0);	ASSERT_RETURN(ret >= 0);	return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR;}

void CGraphicsRigidDiaphragmLoad::translate( const CRigidDiaphragmLoad* pRDL, float length ){	double dLoc[3];	const CNode* pN = pRDL->location();	ASSERT_RETURN( pN );		dLoc[0] = m_loc[0] = pN->x();	dLoc[1] = m_loc[1] = pN->y();	dLoc[2] = m_loc[2] = pN->z();	glMatrixMode( GL_MODELVIEW );	//glPushMatrix();	glTranslatef( (float)m_loc.x, (float)m_loc.y, (float)m_loc.z );	if( !zero( pRDL->magnitude( DX ) ) ){		//draw x dir arrow	}	else if( !zero( pRDL->magnitude( DY ) ) ){		//draw y dir arrow		glRotatef( 90.f, 0.f, 0.f, 1.f );	}	else if( !zero( pRDL->magnitude( DZ ) ) ){		//draw z dir arrow		glRotatef( -90.f, 0.f, 1.f, 0.f );	}	glTranslatef( length, 0.f, 0.f );	//glGetDoublev( GL_MODELVIEW_MATRIX, m_mv );	//glPopMatrix();	return;}