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

Float::Float(QWidget *parent, HistoryItem *item, base::lambda<void(bool visible)> toggleCallback, base::lambda<void(bool closed)> draggedCallback) : TWidget(parent), _item(item), _toggleCallback(std::move(toggleCallback)), _draggedCallback(std::move(draggedCallback)) {	auto media = _item->getMedia();	t_assert(media != nullptr);	auto document = media->getDocument();	t_assert(document != nullptr);	t_assert(document->isRoundVideo());	auto margin = st::mediaPlayerFloatMargin;	auto size = 2 * margin + st::mediaPlayerFloatSize;	resize(size, size);	prepareShadow();	subscribe(Global::RefItemRemoved(), [this](HistoryItem *item) {		if (_item == item) {			detach();		}	});	setCursor(style::cur_pointer);}

void ConnectorTest::makeSocketWithReuseTest(){	// connect to http server on localhost	Connector connector(GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), GetConfig()["SocketConnectSuccessHost"]["port"].AsLong(), 0L, String(), 0L, true);	// assert the internal state	assertEqual( GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), connector.GetAddress() );	assertEqual( GetConfig()["SocketConnectSuccessHost"]["port"].AsLong(), connector.fPort );	assertEqual( (long)NULL, (long)connector.fSocket );	// check basic functionality	Socket *s1 = connector.MakeSocket(false);	Socket *s2 = connector.MakeSocket(false);	long sock1 = 0, sock2 = 0;	if (s1 != 0) {		sock1 = s1->GetFd();		t_assert( s1 != NULL );		if (s2 != 0) {			t_assert( s1 != s2 );		} // if		delete s1;		assertEqual( 0L, ::closeSocket(sock1));	}	if (s2 != 0) {		sock2 = s2->GetFd();		t_assert( s2 != NULL );		delete s2;		// should not result in an error because destructor has not closed socket		assertEqual( 0L, ::closeSocket(sock2));	}} // makeSocketTest

void WorkerPoolManagerTest::EnterLeaveTests() {	StartTrace(WorkerPoolManagerTest.EnterLeaveTests);	const long cPoolSz = 2;	SamplePoolManager wpm("EnterLeaveTestsPool");	Anything config;	config["timeout"] = 1;	config["test"] = Anything((IFAObject *) this);	t_assert(wpm.Init(cPoolSz, 0, 0, 0, ROAnything(config)) == 0);	t_assert(wpm.GetPoolSize() == cPoolSz);	t_assert(wpm.ResourcesUsed() == 0);	Anything work;	for (long i = 0; i < 2 * cPoolSz; i++) {		wpm.Enter(ROAnything(work), -1L);	}	t_assert(wpm.AwaitEmpty(5));	t_assert(wpm.Terminate());	Anything expected;	Anything statistic;	wpm.Statistic(statistic);	expected["PoolSize"] = 2;	expected["CurrentParallelRequests"] = 0;	expected["MaxParallelRequests"] = 2;	expected["TotalRequests"] = 4;	statistic.Remove("TotalTime [ms]"); // since varies	statistic.Remove("AverageTime [ms]"); // since varies	statistic.Remove("TRX/sec"); // since varies	assertAnyEqualm(expected, statistic, "statistic differs");}

void TransitionTests::PBOWBookmarkSequence()//: simulate a privileged bookmark with a subsequent successful login//  privileged request -> PBOWLoginPage ...//  successful login request -> PBOWCustomerOnlyPage2 (now in privileged role) ...//  logout request -> PBOWLoginPage (back to unprivileged role){	Anything r1, r2, r3;	// the session is back in unprivileged mode (or has even been removed)...	// re-play a privileged request:	t_assert(EvalRequest(fBookmarkedRequest, r1));	assertEqual("PBOWLoginPage", r1["page"].AsString());	// login must be enforced	// -- perform successful login using existing session id...	//    original request should be satisfied...	Anything c1 = AddSessionInfo(GetConfig()["GoodLoginRequest"], r1);	t_assert(EvalRequest(c1, r2));	assertEqual("PBOWCustomerOnlyPage2", r2["page"].AsString());	// verify if we are still using the same session	assertEqual(r1["sessionId"].AsString(), r2["sessionId"].AsString());	// -- logout (overwrite r3)	Anything c3 = AddSessionInfo(GetConfig()["LogoutRequest"], r3);	t_assert(EvalRequest(c3, r3));	assertEqual("PBOWLoginPage", r3["page"].AsString());}

void TransitionTests::RunRequestSequence(){	// startup a simple server	Server *server = Server::FindServer("PBOWTypeServer");	if ( t_assert(server != 0) ) {		ServerThread mt(server);		if ( t_assert(mt.Start()) && t_assert(mt.CheckState(Thread::eRunning, 5)) ) {			if ( t_assertm(mt.serverIsInitialized(), "expected initialization to succeed") ) {				mt.SetWorking();				if (t_assertm(mt.IsReady(true, 5), "expected server to become ready within 5 seconds")) {					// --- run various request sequences					PBOWLoginSequence1();					PBOWLoginSequence2();					PBOWFailedBookmarkSequence();					PBOWBookmarkSequence();					mt.PrepareShutdown(0);				}			}			if (t_assertm(mt.IsReady(false, 5), "expected server to become terminated within 5 seconds")) {				mt.Terminate(10);			}		}		t_assertm(mt.CheckState(Thread::eTerminated, 10), "expected server thread to become terminated");	}}

bool TaskQueue::TaskQueueList::Empty(int list_index_) const {	t_assert(list_index_ < kQueuesListsCount);	auto list = lists_[list_index_];	t_assert(list != nullptr);	return (list->list_entries_[list_index_].after == nullptr);}

void paintUnreadBadge(Painter &p, const QRect &rect, const UnreadBadgeStyle &st) {	t_assert(rect.height() == st.size);	int index = (st.muted ? 0x03 : 0x00) + (st.active ? 0x02 : (st.selected ? 0x01 : 0x00));	int size = st.size, sizehalf = size / 2;	unreadBadgeStyle.createIfNull();	auto badgeData = unreadBadgeStyle->sizes;	if (st.sizeId > 0) {		t_assert(st.sizeId < UnreadBadgeSizesCount);		badgeData = &unreadBadgeStyle->sizes[st.sizeId];	}	auto bg = unreadBadgeStyle->bg[index];	if (badgeData->left[index].isNull()) {		int imgsize = size * cIntRetinaFactor(), imgsizehalf = sizehalf * cIntRetinaFactor();		createCircleMask(badgeData, size);		badgeData->left[index] = App::pixmapFromImageInPlace(colorizeCircleHalf(badgeData, imgsize, imgsizehalf, 0, bg));		badgeData->right[index] = App::pixmapFromImageInPlace(colorizeCircleHalf(badgeData, imgsize, imgsizehalf, imgsize - imgsizehalf, bg));	}	int bar = rect.width() - 2 * sizehalf;	p.drawPixmap(rect.x(), rect.y(), badgeData->left[index]);	if (bar) {		p.fillRect(rect.x() + sizehalf, rect.y(), bar, rect.height(), bg);	}	p.drawPixmap(rect.x() + sizehalf + bar, rect.y(), badgeData->right[index]);}

void ServerTest::InitRunResetRunTerminateAcceptorTest() {	StartTrace(ServerTest.InitRunResetRunTerminateAcceptorTest);	TestCaseType::DoUnloadConfig();	for (long i = 0; i < 3; i++) {		TestCaseType::DoLoadConfig("ServerTest", "InitRunResetRunTerminateAcceptorTest");		Server *server = Server::FindServer("AcceptorWorkerServer");		if (t_assertm(server != NULL, "expected AcceptorsWorkersServer to be there")) {			server = (Server *) server->ConfiguredClone("Server", "AcceptorWorkerServerMaster", true);			if (t_assertm(server != NULL, "expected server-clone to succeed")) {				ServerThread mt(server);				if (t_assert(mt.Start()) && t_assert(mt.CheckState(Thread::eRunning, 5))) {					if (t_assertm(mt.serverIsInitialized(), "expected initialization to succeed")) {						mt.SetWorking();						if (t_assertm(mt.IsReady(true, 5), "expected server to become ready within 5 seconds")) {							// --- run various request							//     sequences							RunTestSequence();							if (t_assertm(server->GlobalReinit() == 0, "expected server to reinit ok")) {								RunTestSequence();							}							mt.PrepareShutdown(0);						}					}					if (t_assertm(mt.IsReady(false, 5), "expected server to become terminated within 5 seconds")) {						mt.Terminate(10);					}				}				mt.CheckState(Thread::eTerminated, 5);				server->Finalize();				delete server;			}		}		TestCaseType::DoUnloadConfig();	}}

void PlayButtonLayout::paint(Painter &p, const QBrush &brush) {	if (_transformProgress.animating(getms())) {		auto from = _oldState, to = _state;		auto backward = _transformBackward;		auto progress = _transformProgress.current(1.);		if (from == State::Cancel || (from == State::Pause && to == State::Play)) {			qSwap(from, to);			backward = !backward;		}		if (backward) progress = 1. - progress;		t_assert(from != to);		if (from == State::Play) {			if (to == State::Pause) {				paintPlayToPause(p, brush, progress);			} else {				t_assert(to == State::Cancel);				paintPlayToCancel(p, brush, progress);			}		} else {			t_assert(from == State::Pause && to == State::Cancel);			paintPauseToCancel(p, brush, progress);		}	} else {		switch (_state) {		case State::Play: paintPlay(p, brush); break;		case State::Pause: paintPlayToPause(p, brush, 1.); break;		case State::Cancel: paintPlayToCancel(p, brush, 1.); break;		}	}}

void AudioPlayerLoader::takeSavedDecodedSamples(QByteArray *samples, int64 *samplesCount) {	t_assert(*samplesCount == 0);	t_assert(samples->isEmpty());	t_assert(_holdsSavedSamples);	samples->swap(_savedSamples);	std::swap(*samplesCount, _savedSamplesCount);	_holdsSavedSamples = false;}

void int_to_array__one_byte(){	int symbol = 40;	unsigned char buffer[sizeof(int)];	unsigned int size;	int_to_array(buffer, &size, symbol);	t_assert(size == 1);	t_assert(buffer[0] == 40);}

void int_to_array__negative(){	int symbol = -1;	unsigned char buffer[sizeof(int)];	unsigned int size;	int_to_array(buffer, &size, symbol);	t_assert(size == sizeof(int));	t_assert(buffer[0] == 0xFF);}

void int_to_array__two_bytes(){	int symbol = 258;	unsigned char buffer[sizeof(int)];	unsigned int size;	int_to_array(buffer, &size, symbol);	t_assert(size == 2);	t_assert(buffer[0] == 2);	t_assert(buffer[1] == 1);}

void SocketTest::simpleConstructorTest() {	Connector connector(GetConfig()["SocketConnectSuccessHost"]["ip"].AsString(), GetConfig()["SocketConnectSuccessHost"]["port"].AsLong());	Socket *socket = connector.MakeSocket(); //lint !e578	if (t_assertm( socket != NULL, (const char *)connector.GetAddress() )) {		long socketfd = socket->GetFd();		t_assert( socketfd > 0);		std::iostream *Ios = socket->GetStream();		t_assert( Ios != NULL);	}	delete socket;}

QString FlatTextarea::getInlineBotQuery(UserData **outInlineBot, QString *outInlineBotUsername) const {	t_assert(outInlineBot != nullptr);	t_assert(outInlineBotUsername != nullptr);	const QString &text(getLastText());	int32 inlineUsernameStart = 1, inlineUsernameLength = 0, size = text.size();	if (size > 2 && text.at(0) == '@' && text.at(1).isLetter()) {		inlineUsernameLength = 1;		for (int32 i = inlineUsernameStart + 1, l = text.size(); i < l; ++i) {			if (text.at(i).isLetterOrNumber() || text.at(i).unicode() == '_') {				++inlineUsernameLength;				continue;			}			if (!text.at(i).isSpace()) {				inlineUsernameLength = 0;			}			break;		}		if (inlineUsernameLength && inlineUsernameStart + inlineUsernameLength < text.size() && text.at(inlineUsernameStart + inlineUsernameLength).isSpace()) {			QStringRef username = text.midRef(inlineUsernameStart, inlineUsernameLength);			if (username != *outInlineBotUsername) {				*outInlineBotUsername = username.toString();				PeerData *peer = App::peerByName(*outInlineBotUsername);				if (peer) {					if (peer->isUser()) {						*outInlineBot = peer->asUser();					} else {						*outInlineBot = nullptr;					}				} else {					*outInlineBot = LookingUpInlineBot;				}			}			if (*outInlineBot == LookingUpInlineBot) return QString();			if (*outInlineBot && (!(*outInlineBot)->botInfo || (*outInlineBot)->botInfo->inlinePlaceholder.isEmpty())) {				*outInlineBot = nullptr;			} else {				return text.mid(inlineUsernameStart + inlineUsernameLength + 1);			}		} else {			inlineUsernameLength = 0;		}	}	if (inlineUsernameLength < 3) {		*outInlineBot = nullptr;		*outInlineBotUsername = QString();	}	return QString();}

//---- NewRendererTest ----------------------------------------------------------------void NewRendererTest::TestCases() {	StartTrace(NewRendererTest.TestCases);	if (t_assertm( !GetTestCaseConfig().IsNull(), "no Tests configured!" )) {		Server *theServer = Server::FindServer("Server");		t_assert(theServer != NULL);		Context ctx;		Session theSession("TestSession");		Page *thePage = Page::FindPage("TestPage");		t_assert(thePage != NULL);		Role *theRole = Role::FindRole("TestRole");		t_assert(theRole != NULL);		theSession.Init("TestSession", ctx);		AnyExtensions::Iterator<ROAnything, ROAnything, TString> aEntryIterator(GetTestCaseConfig());		ROAnything roaCaseConfig;		t_assertm( GetConfig()["RunOnly"].GetSize() == 0L, "running only subset of tests");		TraceAny(GetConfig()["RunOnly"], "run only config")		while (aEntryIterator.Next(roaCaseConfig)) {			TString slotToCheck;			aEntryIterator.SlotName(slotToCheck);			Trace("current testslot [" << slotToCheck << "]");			if ((GetConfig()["RunOnly"].GetSize() == 0L) || GetConfig()["RunOnly"].Contains((const char *) slotToCheck)) {				std::cerr << ".";				TString message;				message << getConfigFileName() << ".any:0 at " << name();				if (slotToCheck.Length()) {					message << "." << slotToCheck;				} else {					message << ":" << aEntryIterator.Index();				}				Context c(GetConfig()["EnvForAllCases"].DeepClone(), roaCaseConfig["Env"].DeepClone(), theServer, &theSession, theRole,						thePage);				coast::testframework::PutInStore(roaCaseConfig["TmpStore"], c.GetTmpStore());				coast::testframework::PutInStore(roaCaseConfig["SessionStore"], c.GetSessionStore());				TraceAny(roaCaseConfig["Renderer"], "running renderer at [" << slotToCheck << "]");				String result("[");				String expected("[");				expected << roaCaseConfig["Expected"].AsCharPtr("") << "]";				{					OStringStream reply(result);					Renderer::Render(reply, c, roaCaseConfig["Renderer"]);					reply.flush();				}				result.Append(']');				// message << ":/n" << result;				assertEqualm(expected, result, message);			}		}	}

void HTTPPostRequestBodyParserTest::ReadMultiPartPost(){	StartTrace(HTTPPostRequestBodyParserTest.ReadMultiPartPost);	std::iostream *is = coast::system::OpenStream("MultiPartBody.txt", 0);	t_assertm(is != 0, "expected 'MultiPartBody.txt' to be there");	if ( is ) {		MIMEHeader mh;		t_assertm(mh.ParseHeaders(*is, 4096, 4096), "expected global header parsing to succeed");		assertEqual(586L, mh.GetParsedHeaderLength());		HTTPPostRequestBodyParser sm(mh);		t_assert(sm.Parse(*is));		Anything expected;		Anything result = sm.GetContent();		delete is;		t_assert(!GetConfig().IsNull());		assertAnyEqual(GetConfig()["MultiPartResult"], result);	}	// This sequence takes advantage of the String::SubString	// feature to return the whole remainder of the string starting	// from the first occurrence the substring-pattern has been found.	// This relieves us from the need to create an expected result file	// which we would use to verify the results.	is =  coast::system::OpenStream("MultiPartBody.txt", 0);	if ( is ) {		MIMEHeader mh;		t_assertm(mh.ParseHeaders(*is, 4096, 4096), "expected global header parsing to succeed");		assertEqual(586L, mh.GetParsedHeaderLength());		HTTPPostRequestBodyParser sm(mh);		t_assert(sm.Parse(*is));		String unparsedContent = sm.GetUnparsedContent();		delete is;		is =  coast::system::OpenStream("MultiPartBody.txt", 0);		if (is) {			char c;			String tmp;			while ((!!(*is).get(c))) {				tmp.Append(c);			}			String final;			final = tmp.SubString(unparsedContent);			assertEqual(final, unparsedContent);			delete is;		}	}

static voidt4(void) {	int		result;	isc_time_t	expires;	isc_interval_t	interval;	t_assert("isc_timer_reset", 4, T_REQUIRED, "%s", a4);	if (threaded) {		Tx_nfails = 0;		Tx_nprobs = 0;		Tx_nevents = 3;		Tx_seconds = T4_SECONDS;		Tx_nanoseconds = T4_NANOSECONDS;		isc_interval_set(&interval, T4_SECONDS, T4_NANOSECONDS);		isc_time_settoepoch(&expires);		t_timers_x(isc_timertype_ticker, &expires, &interval, t4_te);		result = T_UNRESOLVED;		if ((Tx_nfails == 0) && (Tx_nprobs == 0))			result = T_PASS;		else if (Tx_nfails)			result = T_FAIL;		t_result(result);	} else		require_threads();}

static void _parse_parent_child_nonterminal(){	ParserContext context;	Ast ast;	AstBuilder builder;	_build_child_rule_fsm(&fix.parser.fsm);	ast_init(&ast, NULL, &fix.parser.table);	ast_builder_init(&builder, &ast);	ast_builder_append_follow(&builder, &(Token){1, 1, 'a'});	ast_builder_append(&builder, &(Token){2, 1, 'b'});	ast_builder_append(&builder, &(Token){3, 1, 'c'});	ast_builder_done(&builder);	ast_builder_dispose(&builder);	parser_context_init(&context, &fix.parser);	parser_context_set_source_ast(&context, &ast);	int error = parser_context_execute(&context);	t_assert(!error);	parser_context_dispose(&context);	ast_dispose(&ast);}

static void _parse_sibling_with_children_test(){	ParserContext context;	Ast ast;	AstBuilder builder;	_build_siblings_with_children(&fix.parser.fsm);	ast_init(&ast, NULL, &fix.parser.table);	ast_builder_init(&builder, &ast);	ast_builder_append_follow(&builder, &(Token){1, 1, 'a'});	ast_builder_append(&builder, &(Token){2, 1, 'b'});	ast_builder_append(&builder, &(Token){3, 1, 'c'});	ast_builder_parent(&builder);	ast_builder_append_follow(&builder, &(Token){4, 1, 'd'});	ast_builder_append(&builder, &(Token){5, 1, 'e'});	ast_builder_append(&builder, &(Token){6, 1, 'f'});	ast_builder_done(&builder);	ast_builder_dispose(&builder);	parser_context_init(&context, &fix.parser);	parser_context_set_source_ast(&context, &ast);	int error = parser_context_execute(&context);	t_assert(!error);	parser_context_dispose(&context);	ast_dispose(&ast);}

void _parser_basic_parse(){	ParserContext context;	Ast ast;	AstBuilder builder;	_build_simple_ab_fsm(&fix.parser.fsm);	ast_init(&ast, NULL, &fix.parser.table);	ast_builder_init(&builder, &ast);	ast_builder_append_follow(&builder, &(Token){1, 1, 'a'});	ast_builder_append(&builder, &(Token){2, 1, 'b'});	ast_builder_done(&builder);	ast_builder_dispose(&builder);	parser_context_init(&context, &fix.parser);	parser_context_set_source_ast(&context, &ast);	int error = parser_context_execute(&context);	t_assert(!error);	parser_context_dispose(&context);	ast_dispose(&ast);}

void destroyShortcut(QShortcut *shortcut) {	t_assert(DataPtr != nullptr);	DataPtr->handlers.remove(shortcut->id());	DataPtr->mediaShortcuts.remove(shortcut);	delete shortcut;}

static voidtest_dns_resolver_settimeout_to_default(void) {	dns_resolver_t *resolver = NULL;	int test_result;	unsigned int default_timeout, timeout;	t_assert("test_dns_resolver_settimeout_to_default", 1, T_REQUIRED, "%s",		 "_settimeout() can change the timeout back to a default value"		 " by specifying 0 as the timeout.");	setup();	CHECK(make_resolver(&resolver));	default_timeout = dns_resolver_gettimeout(resolver);	t_info("The default timeout is %d second%s/n", default_timeout,	       (default_timeout == 1 ? "" : "s"));	dns_resolver_settimeout(resolver, default_timeout - 1);	timeout = dns_resolver_gettimeout(resolver);	t_info("The new timeout is %d second%s/n", timeout,	       (timeout == 1 ? "" : "s"));	dns_resolver_settimeout(resolver, 0);	timeout = dns_resolver_gettimeout(resolver);	test_result = (timeout == default_timeout) ? T_PASS : T_FAIL;	destroy_resolver(&resolver);	teardown();	t_result(test_result);}