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

void TextureRenderer::SetUp() {    const char vsrc[] =        "attribute vec4 vPosition;/n"        "varying vec2 texCoords;/n"        "uniform mat4 texMatrix;/n"        "void main() {/n"        "  vec2 vTexCoords = 0.5 * (vPosition.xy + vec2(1.0, 1.0));/n"        "  texCoords = (texMatrix * vec4(vTexCoords, 0.0, 1.0)).xy;/n"        "  gl_Position = vPosition;/n"        "}/n";    const char fsrc[] =        "#extension GL_OES_EGL_image_external : require/n"        "precision mediump float;/n"        "uniform samplerExternalOES texSampler;/n"        "varying vec2 texCoords;/n"        "void main() {/n"        "  gl_FragColor = texture2D(texSampler, texCoords);/n"        "}/n";    {        SCOPED_TRACE("creating shader program");        ASSERT_NO_FATAL_FAILURE(GLTest::createProgram(vsrc, fsrc, &mPgm));    }    mPositionHandle = glGetAttribLocation(mPgm, "vPosition");    ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());    ASSERT_NE(-1, mPositionHandle);    mTexSamplerHandle = glGetUniformLocation(mPgm, "texSampler");    ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());    ASSERT_NE(-1, mTexSamplerHandle);    mTexMatrixHandle = glGetUniformLocation(mPgm, "texMatrix");    ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());    ASSERT_NE(-1, mTexMatrixHandle);}

TEST_F(WalletApi, initAndSave) {  SaveOnInitWalletObserver saveOnInit(alice.get());  alice->addObserver(&saveOnInit);  alice->initAndGenerate("pass");  ASSERT_NO_FATAL_FAILURE(WaitWalletSave(aliceWalletObserver.get()));  alice->shutdown();}

// Tests an interactive PTY session.TEST_F(ShellServiceTest, InteractivePtySubprocess) {    ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(                                "", SubprocessType::kPty, SubprocessProtocol::kShell));    // Use variable substitution so echoed input is different from output.    const char* commands[] = {"TEST_STR=abc123",                              "echo --${TEST_STR}--",                              "exit"                             };    ShellProtocol* protocol = new ShellProtocol(subprocess_fd_);    for (std::string command : commands) {        // Interactive shell requires a newline to complete each command.        command.push_back('/n');        memcpy(protocol->data(), command.data(), command.length());        ASSERT_TRUE(protocol->Write(ShellProtocol::kIdStdin, command.length()));    }    delete protocol;    std::string stdout, stderr;    EXPECT_EQ(0, ReadShellProtocol(subprocess_fd_, &stdout, &stderr));    // An unpredictable command prompt makes parsing exact output difficult but    // it should at least contain echoed input and the expected output.    for (const char* command : commands) {        EXPECT_FALSE(stdout.find(command) == std::string::npos);    }    EXPECT_FALSE(stdout.find("--abc123--") == std::string::npos);}

void XITServerTest::StartServer() {    /* No test takes longer than 60 seconds unless we have some envs set       that suggest we're actually debugging the server */    if (!getenv("XORG_GTEST_XSERVER_SIGSTOP") &&        !getenv("XORG_GTEST_XSERVER_KEEPALIVE") &&        !getenv("XORG_GTEST_USE_VALGRIND")) {        alarm(TEST_TIMEOUT);        signal(SIGALRM, sighandler_alarm);    }    server.SetOption("-noreset", "");    server.SetOption("-logverbose", "12");    server.Start();    std::string display;    const char *dpy = getenv("XORG_GTEST_XSERVER_OVERRIDE_DISPLAY");    if (dpy)        display = std::string(dpy);    else        display = server.GetDisplayString();    xorg::testing::Test::SetDisplayString(display);    ASSERT_NO_FATAL_FAILURE(xorg::testing::Test::SetUp());}

 void getCurrentMode(uint32_t &w, uint32_t &h) {     adf_interface_data data;     ASSERT_NO_FATAL_FAILURE(getInterfaceData(data));     w = data.current_mode.hdisplay;     h = data.current_mode.vdisplay;     adf_free_interface_data(&data); }

TEST_F(DlExtRelroSharingTest, RelroFileEmpty) {  int relro_fd = open(relro_file_, O_CREAT | O_RDWR | O_TRUNC, 0644);  ASSERT_NOERROR(relro_fd);  ASSERT_NOERROR(close(relro_fd));  ASSERT_NO_FATAL_FAILURE(TryUsingRelro(LIBNAME));}

TEST_F(IGraphicBufferProducerTest, Query_ReturnsError) {    ASSERT_NO_FATAL_FAILURE(ConnectProducer());    // One past the end of the last 'query' enum value. Update this if we add more enums.    const int NATIVE_WINDOW_QUERY_LAST_OFF_BY_ONE = NATIVE_WINDOW_BUFFER_AGE + 1;    int value;    // What was out of range    EXPECT_EQ(BAD_VALUE, mProducer->query(/*what*/-1, &value));    EXPECT_EQ(BAD_VALUE, mProducer->query(/*what*/0xDEADBEEF, &value));    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_QUERY_LAST_OFF_BY_ONE, &value));    // Some enums from window.h are 'invalid'    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, &value));    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_CONCRETE_TYPE, &value));    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_DEFAULT_WIDTH, &value));    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_DEFAULT_HEIGHT, &value));    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_TRANSFORM_HINT, &value));    // TODO: Consider documented the above enums as unsupported or make a new enum for IGBP    // Value was NULL    EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_FORMAT, /*value*/NULL));    ASSERT_OK(mConsumer->consumerDisconnect());    // BQ was abandoned    EXPECT_EQ(NO_INIT, mProducer->query(NATIVE_WINDOW_FORMAT, &value));    // TODO: other things in window.h that are supported by Surface::query    // but not by BufferQueue::query}

void runWithCipher(const string& cipherName, int blockSize,                   void (*func)(FSConfigPtr& config)) {  shared_ptr<CipherV1> cipher = CipherV1::New(cipherName);  ASSERT_TRUE(cipher.get() != NULL);  FSConfigPtr cfg = makeConfig(cipher, blockSize);  ASSERT_NO_FATAL_FAILURE(func(cfg));}

 void drawTexture(bool asSRGB, GLint x, GLint y, GLsizei width,         GLsizei height) {     ASSERT_NO_FATAL_FAILURE(fillTexture(asSRGB));     glViewport(x, y, width, height);     ASSERT_EQ(GL_NO_ERROR, glGetError());     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);     ASSERT_EQ(GL_NO_ERROR, glGetError()); }

TEST(TraceLifecycleTest, threadAttachDetachStress){	/* OMR VM data structures */	OMRTestVM testVM;	OMR_VMThread *vmthread = NULL;	const int attachDetachHelpersCount = 10;	omrthread_t attachDetachHelpers[attachDetachHelpersCount];	ChildThreadData *attachDetachData[attachDetachHelpersCount];	omrthread_t shutdownHelper = NULL;	ChildThreadData *shutdownData = NULL;	OMRPORT_ACCESS_FROM_OMRPORT(rasTestEnv->getPortLibrary());	char *datDir = getTraceDatDir(rasTestEnv->_argc, (const char **)rasTestEnv->_argv);	OMRTEST_ASSERT_ERROR_NONE(omrTestVMInit(&testVM, OMRPORTLIB));	/* use small buffers to exercise buffer wrapping */	OMRTEST_ASSERT_ERROR_NONE(omr_ras_initTraceEngine(&testVM.omrVM, "buffers=1k:maximal=all", datDir));	/* Attach the thread to the trace engine */	OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "registerSubscriberAfterShutdown"));	UT_OMR_TEST_MODULE_LOADED(testVM.omrVM._trcEngine->utIntf);	/* module is not unloaded before trace engine shutdown */	for (int i = 0; i < attachDetachHelpersCount; i++) {		ASSERT_NO_FATAL_FAILURE(startChildThread(&testVM, &attachDetachHelpers[i], attachDetachHelper, &attachDetachData[i]));	}	ASSERT_NO_FATAL_FAILURE(startChildThread(&testVM, &shutdownHelper, shutdownTraceHelper, &shutdownData));	for (int i = 0; i < attachDetachHelpersCount; i++) {		ASSERT_EQ(1, omrthread_resume(attachDetachHelpers[i]));	}	ASSERT_EQ(1, omrthread_resume(shutdownHelper));	for (int i = 0; i < attachDetachHelpersCount; i++) {		OMRTEST_ASSERT_ERROR_NONE(waitForChildThread(&testVM, attachDetachHelpers[i], attachDetachData[i]));	}	OMRTEST_ASSERT_ERROR_NONE(waitForChildThread(&testVM, shutdownHelper, shutdownData));	/* Now clear up the VM we started for this test case. */	UT_OMR_TEST_MODULE_UNLOADED(testVM.omrVM._trcEngine->utIntf);	OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread));	OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM));	ASSERT_TRUE(NULL == (void *)omr_test_UtModuleInfo.intf);}

TEST_F(SelectionCollectionTest, HandlesUnsupportedRegularExpressions){    if (!gmx::Regex::isSupported())    {        ASSERT_NO_FATAL_FAILURE(loadTopology("simple.gro"));        EXPECT_THROW_GMX({                             sc_.parseFromString("resname /"R[AD]/"");                             sc_.compile();                         }, gmx::InvalidInputError);

TEST_F(InputPublisherAndConsumerTest, AppendMotionSample_WhenNoMotionEventPublished_ReturnsError) {    status_t status;    ASSERT_NO_FATAL_FAILURE(Initialize());    PointerCoords pointerCoords[1];    status = mPublisher->appendMotionSample(0, pointerCoords);    ASSERT_EQ(INVALID_OPERATION, status)            << "publisher appendMotionSample should return INVALID_OPERATION";}

TEST(JoinTest, createDetachedThread){	omrthread_t helperThr = NULL;	/* We can't pass any local data to the child thread because we don't guarantee that	 * it won't go out of scope before the child thread uses it.	 */	ASSERT_NO_FATAL_FAILURE(createThread(&helperThr, FALSE, J9THREAD_CREATE_DETACHED, doNothingHelper, NULL));}

TEST( CFPP_WriteStream, Close ){    CF::WriteStream s1;    CF::WriteStream s2( "/etc/hosts" );    CF::WriteStream s3( "/tmp/com.xs-labs.cfpp" );        s1.Open();    s2.Open();    s3.Open();        ASSERT_NO_FATAL_FAILURE( s1.Close() );    ASSERT_NO_FATAL_FAILURE( s2.Close() );    ASSERT_NO_FATAL_FAILURE( s3.Close() );        ASSERT_NO_THROW( s1.Close() );    ASSERT_NO_THROW( s2.Close() );    ASSERT_NO_THROW( s3.Close() );}

TEST_F(MotionEventTest, CopyFrom_KeepHistory) {    MotionEvent event;    initializeEventWithHistory(&event);    MotionEvent copy;    copy.copyFrom(&event, true /*keepHistory*/);    ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event));}

TEST_F(AdfTest, attach) {    ASSERT_NO_FATAL_FAILURE(attach());    int err = adf_device_attach(&dev, eng_id, intf_id);    EXPECT_EQ(-EALREADY, err) << "attaching overlay engine " << eng_id <<            " to interface " << intf_id << " twice should have failed";    ASSERT_NO_FATAL_FAILURE(detach());    err = adf_device_detach(&dev, eng_id, intf_id);    EXPECT_EQ(-EINVAL, err) << "detaching overlay engine " << eng_id <<            " from interface " << intf_id << " twice should have failed";    err = adf_device_attach(&dev, eng_id, ADF_MAX_INTERFACES);    EXPECT_EQ(-EINVAL, err) << "attaching overlay engine " << eng_id <<            " to bogus interface should have failed";    err = adf_device_detach(&dev, eng_id, ADF_MAX_INTERFACES);    EXPECT_EQ(-EINVAL, err) << "detaching overlay engine " << eng_id <<            " from bogus interface should have failed";}

TEST_F(WalletApi, saveAndLoadErroneousTxsCacheNoDetails) {  prepareBobWallet();  prepareCarolWallet();  alice->initAndGenerate("pass");  ASSERT_NO_FATAL_FAILURE(WaitWalletSync(aliceWalletObserver.get()));  ASSERT_NO_FATAL_FAILURE(GetOneBlockReward(*alice));  generator.generateEmptyBlocks(10);  alice->startRefresh();  ASSERT_NO_FATAL_FAILURE(WaitWalletSync(aliceWalletObserver.get()));  bob->initAndGenerate("pass");  ASSERT_NO_FATAL_FAILURE(WaitWalletSync(bobWalletObserver.get()));  carol->initAndGenerate("pass");  ASSERT_NO_FATAL_FAILURE(WaitWalletSync(carolWalletObserver.get()));  std::array<int64_t, 5> amounts;  amounts[0] = 1234567;  amounts[1] = 1345678;  amounts[2] = 1456789;  amounts[3] = 1567890;  amounts[4] = 1678901;  uint64_t fee = 10000;  ASSERT_NO_FATAL_FAILURE(performTransferWithErrorTx(amounts, fee));  std::stringstream archive;  alice->save(archive, false, true);  ASSERT_NO_FATAL_FAILURE(WaitWalletSave(aliceWalletObserver.get()));  prepareAliceWallet();  alice->initAndLoad(archive, "pass");  std::error_code result;  ASSERT_NO_FATAL_FAILURE(WaitWalletLoad(aliceWalletObserver.get(), result));  ASSERT_EQ(result.value(), 0);  EXPECT_EQ(alice->getTransactionCount(), 2);  EXPECT_EQ(alice->getTransferCount(), 0);  CryptoNote::Transaction tx;  ASSERT_TRUE(alice->getTransaction(1, tx));  EXPECT_EQ(tx.totalAmount, amounts[3] + amounts[4] + fee);  EXPECT_EQ(tx.firstTransferId, CryptoNote::INVALID_TRANSFER_ID);  EXPECT_EQ(tx.transferCount, 0);  alice->shutdown();}