TEST(TraceLifecycleTest, moduleUnloadAfterThreadDetach) { /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = NULL; omrthread_t childThread = NULL; ChildThreadData *childData = 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:print=omr_test", datDir)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "moduleLoadBeforeThreadAttach")); ASSERT_NO_FATAL_FAILURE(startChildThread(&testVM, &childThread, moduleUnloadAfterThreadDetachHelper, &childData)); ASSERT_EQ(1, omrthread_resume(childThread)); OMRTEST_ASSERT_ERROR_NONE(waitForChildThread(&testVM, childThread, childData)); /* Unload the module that was left loaded by the child thread */ UT_OMR_TEST_MODULE_UNLOADED(testVM.omrVM._trcEngine->utIntf); /* Now clear up the VM we started for this test case. */ OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); ASSERT_TRUE(NULL == (void *)omr_test_UtModuleInfo.intf); }
TEST(TraceLifecycleTest, deregisterSubscriberAfterShutdown) { /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = NULL; UtSubscription *subscriptionID = NULL; const OMR_TI *ti = omr_agent_getTI(); 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:print=omr_test", datDir)); /* Attach the thread to the trace engine */ OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "registerSubscriberAfterShutdown")); /* Register the subscriber */ OMRTEST_ASSERT_ERROR_NONE( ti->RegisterRecordSubscriber(vmthread, "registerSubscriberAfterShutdown", subscribeFunc, NULL, NULL, &subscriptionID)); /* Shut down the trace engine */ OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread)); /* Attempt to deregister using external agent API. This succeeds because this thread is still attached to the trace engine. */ OMRTEST_ASSERT_ERROR_NONE(ti->DeregisterRecordSubscriber(vmthread, subscriptionID)); /* Now clear up the VM we started for this test case. */ OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); ASSERT_TRUE(NULL == (void *)omr_test_UtModuleInfo.intf); }
TEST(RASMemoryCategoriesTest, Agent) { /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = NULL; const char *agentName = "memorycategoriesagent"; struct OMR_Agent *agent = NULL; OMRTEST_ASSERT_ERROR_NONE(omrTestVMInit(&testVM, rasTestEnv->getPortLibrary())); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "memoryCategoriesTest")); /* load memorycategoriesagent */ agent = omr_agent_create(&testVM.omrVM, agentName); ASSERT_FALSE(NULL == agent) << "createAgent(" << agentName << ") failed"; OMRTEST_ASSERT_ERROR_NONE(omr_agent_openLibrary(agent)); OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnLoad(agent)); /** The test code is actually in the OnLoadFunction **/ /* Unload the agent */ omr_agent_callOnUnload(agent); omr_agent_destroy(agent); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); /* Now clear up the VM we started for this test case. */ OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); }
virtual void TearDown() { #if defined(WIN32) WSACleanup(); #endif /* defined(WIN32) */ OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); }
TEST(RASTraceOptionTest, TraceOptionAgent) { /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = NULL; /* OMR Trace data structures */ const char *trcOpts = "print=all"; struct OMR_Agent *agent = NULL; OMRPORT_ACCESS_FROM_OMRPORT(rasTestEnv->getPortLibrary()); char *datDir = NULL; OMRTEST_ASSERT_ERROR_NONE(omrTestVMInit(&testVM, OMRPORTLIB)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "traceOptionTest")); datDir = getTraceDatDir(rasTestEnv->_argc, (const char **)rasTestEnv->_argv); OMRTEST_ASSERT_ERROR_NONE(omr_ras_initTraceEngine(&testVM.omrVM, trcOpts, datDir)); OMRTEST_ASSERT_ERROR_NONE(omr_trc_startThreadTrace(vmthread, "initialization thread")); /* load agent */ agent = omr_agent_create(&testVM.omrVM, "traceOptionAgent"); ASSERT_FALSE(NULL == agent) << "testAgent: createAgent() traceOptionAgent failed"; OMRTEST_ASSERT_ERROR_NONE(omr_agent_openLibrary(agent)); OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnLoad(agent)); /* Initialise the omr_test module for tracing */ UT_OMR_TEST_MODULE_LOADED(testVM.omrVM._trcEngine->utIntf); /* Fire some trace points! */ Trc_OMR_Test_Init(); Trc_OMR_Test_Ptr(vmthread, vmthread); Trc_OMR_Test_Int(vmthread, 10); Trc_OMR_Test_Int(vmthread, 99); Trc_OMR_Test_ManyParms(vmthread, "Hello again!", vmthread, 10); UT_OMR_TEST_MODULE_UNLOADED(testVM.omrVM._trcEngine->utIntf); /* Unload the agent */ OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnUnload(agent)); omr_agent_destroy(agent); Trc_OMR_Test_String(vmthread, "This tracepoint should be ignored."); OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); /* Now clear up the VM we started for this test case. */ OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); }
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); }
/* * This test just starts up and shuts down the trace engine. * Run it in a loop to check for memory leaks. */ TEST(TraceLifecycleTest, startupShutdownSanity) { /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = NULL; OMRPORT_ACCESS_FROM_OMRPORT(rasTestEnv->getPortLibrary()); 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:print=omr_test", ".")); /* Attach the thread to the trace engine */ OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "stub")); /* Now clear up the VM we started for this test case. */ OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); }
/* * Without ENABLE_BUGS, this test doesn't test anything. */ TEST(TraceLifecycleTest, DISABLE_moduleLoadAfterTraceShutdown) { /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = 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:print=omr_test", datDir)); /* Attach the thread to the trace engine */ OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "moduleLoadAfterTraceShutdown")); #if ENABLE_BUGS /* cache the UtInterface */ UtInterface *utIntf = testVM.omrVM._trcEngine->utIntf; #endif /* ENABLE_BUGS */ /* Shut down the trace engine */ OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread)); ASSERT_TRUE(NULL == vmthread->_vm->utIntf); ASSERT_TRUE(NULL == (void *)testVM.omrVM._trcEngine); #if ENABLE_BUGS /* Attempt to load a module. Note this requires bogus caching of UtInterface*, and using it after it was freed. */ /* moduleLoaded() crashes on attempt to use omrTraceGlobal */ UT_OMR_TEST_MODULE_LOADED(utIntf); Trc_OMR_Test_UnloggedTracepoint(vmthread, "The module was loaded after trace shutdown."); UT_OMR_TEST_MODULE_UNLOADED(utIntf); #endif /* ENABLE_BUGS */ /* Now clear up the VM we started for this test case. */ OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); ASSERT_TRUE(NULL == (void *)omr_test_UtModuleInfo.intf); }
TEST(TraceLifecycleTest, moduleLoadBeforeThreadAttach) { /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = NULL; const OMR_TI *ti = omr_agent_getTI(); UtSubscription *subscriptionID = NULL; TracePointCounts tpCounts; memset(&tpCounts, 0, sizeof(tpCounts)); tpCounts.osThread = omrthread_self(); initWrapBuffer(&tpCounts.wrapBuffer); 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:print=omr_test", datDir)); /* Attempt to load a module before attaching the thread. This should fail silently without crashing */ UT_OMR_TEST_MODULE_LOADED(testVM.omrVM._trcEngine->utIntf); /* Attach the thread to the trace engine */ OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "moduleLoadBeforeThreadAttach")); OMRTEST_ASSERT_ERROR_NONE( ti->RegisterRecordSubscriber(vmthread, "moduleLoadBeforeThreadAttach", countTracepoints, NULL, (void *)&tpCounts, &subscriptionID)); /* Attempt to log a tracepoint. Nothing should happen. */ Trc_OMR_Test_UnloggedTracepoint(vmthread, "The trace module was loaded before the current thread was attached."); #if ENABLE_BUGS /* This can't be done because there is no check for whether the module was actually loaded. */ UT_OMR_TEST_MODULE_UNLOADED(testVM.omrVM._trcEngine->utIntf); #endif /* ENABLE_BUGS */ /* This should succeed. */ UT_OMR_TEST_MODULE_LOADED(testVM.omrVM._trcEngine->utIntf); Trc_OMR_Test_String(vmthread, "This tracepoint should appear."); UT_OMR_TEST_MODULE_UNLOADED(testVM.omrVM._trcEngine->utIntf); /* Now clear up the VM we started for this test case. */ OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread)); /* * Must not deregister before omr_ras_cleanupTraceEngine() because cleanup flushes the trace buffers. * This succeeds for a weird reason: omr_ras_cleanupTraceEngine() actually deregistered all * subscribers when it detached the current thread. This Deregister call does nothing. */ OMRTEST_ASSERT_ERROR_NONE(ti->DeregisterRecordSubscriber(vmthread, subscriptionID)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); /* Validate the number of tracepoints */ ASSERT_EQ(0, tpCounts.unloggedCount); ASSERT_EQ(1, tpCounts.loggedCount); freeWrapBuffer(&tpCounts.wrapBuffer); ASSERT_TRUE(NULL == (void *)omr_test_UtModuleInfo.intf); }
/* * Tests: * - Attempt to log a tracepoint after trace engine shutdown started. * - Attempt to unload a module after trace engine shutdown started. * * If module unloading fails, this test case tends to cause later tests * to crash because the static omr_test_UtModuleInfo and omr_test_UtActive * structures are left in a polluted state. */ TEST(TraceLifecycleTest, traceAndModuleUnloadAfterTraceShutdown) { const OMR_TI *ti = omr_agent_getTI(); UtSubscription *subscriptionID = NULL; /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = NULL; /* child thread data */ omrthread_t shutdownTrcThr = NULL; ChildThreadData *shutdownTrcData = NULL; TracePointCountsMT tpCountsMT; TracePointCounts tpCounts[2]; tpCountsMT.numThreads = 2; tpCountsMT.tpCounts = tpCounts; memset(tpCounts, 0, sizeof(TracePointCounts) * 2); initWrapBuffer(&tpCounts[0].wrapBuffer); initWrapBuffer(&tpCounts[1].wrapBuffer); tpCounts[0].osThread = omrthread_self(); ASSERT_EQ(0, omrthread_monitor_init_with_name(&tpCountsMT.lock, 0, "&tpCountsMT.lock")); 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:print=omr_test", datDir)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "traceTest")); /* start counting tracepoints */ OMRTEST_ASSERT_ERROR_NONE( ti->RegisterRecordSubscriber(vmthread, "traceAndModuleUnloadAfterTraceShutdown", countTracepointsMT, NULL, (void *)&tpCountsMT, &subscriptionID)); /* Initialise the omr_test module for tracing */ UT_OMR_TEST_MODULE_LOADED(testVM.omrVM._trcEngine->utIntf); /* Shut down the trace engine */ ASSERT_NO_FATAL_FAILURE(startChildThread(&testVM, &shutdownTrcThr, shutdownTraceHelper, &shutdownTrcData)); ASSERT_EQ(1, omrthread_resume(shutdownTrcThr)); OMRTEST_ASSERT_ERROR_NONE(waitForChildThread(&testVM, shutdownTrcThr, shutdownTrcData)); /* Attempt to log a tracepoint. It will not be logged. */ Trc_OMR_Test_UnloggedTracepoint(vmthread, "Tracepoint initiated after trace engine shutdown is started."); UT_OMR_TEST_MODULE_UNLOADED(testVM.omrVM._trcEngine->utIntf); /* Now clear up the VM we started for this test case. */ /* Stop counting tracepoints */ omr_trc_stopThreadTrace(vmthread); /* flush the thread's trace buffer and delete all subscribers */ OMRTEST_ASSERT_ERROR_NONE(ti->DeregisterRecordSubscriber(vmthread, subscriptionID)); /* do nothing */ OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); ASSERT_EQ(0, tpCounts[0].unloggedCount); ASSERT_EQ(0, tpCounts[0].loggedCount); freeWrapBuffer(&tpCounts[0].wrapBuffer); ASSERT_EQ(0, tpCounts[1].unloggedCount); ASSERT_EQ(0, tpCounts[1].loggedCount); freeWrapBuffer(&tpCounts[1].wrapBuffer); ASSERT_EQ(0, omrthread_monitor_destroy(tpCountsMT.lock)); ASSERT_TRUE(NULL == (void *)omr_test_UtModuleInfo.intf); }
TEST(RASTraceTest, TraceAgent) { struct OMR_Agent *agent = NULL; /* OMR VM data structures */ OMRTestVM testVM; OMR_VMThread *vmthread = NULL; /* child thread data */ omrthread_t childThread = NULL; TestChildThreadData *childData = NULL; OMRPORT_ACCESS_FROM_OMRPORT(rasTestEnv->getPortLibrary()); char *datDir = getTraceDatDir(rasTestEnv->_argc, (const char **)rasTestEnv->_argv); OMRTEST_ASSERT_ERROR_NONE(omrTestVMInit(&testVM, OMRPORTLIB)); /* WARNING: This negative test leaks memory. */ OMRTEST_ASSERT_ERROR(omr_ras_initTraceEngine(&testVM.omrVM, "print=all:duck=quack", datDir), OMR_ERROR_ILLEGAL_ARGUMENT); OMRTEST_ASSERT_ERROR_NONE(omr_ras_initTraceEngine(&testVM.omrVM, "maximal=all", datDir)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "traceTest")); #if TEST_TRACEAGENT /* load traceagent */ { agent = omr_agent_create(&testVM.omrVM, "traceagent"); ASSERT_FALSE(NULL == agent) << "testAgent: createAgent() traceagent failed"; OMRTEST_ASSERT_ERROR_NONE(omr_agent_openLibrary(agent)); OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnLoad(agent)); } #endif /* TEST_TRACEAGENT */ /* Initialise the omr_test module for tracing */ UT_OMR_TEST_MODULE_LOADED(testVM.omrVM._trcEngine->utIntf); /* Fire some trace points! */ Trc_OMR_Test_Init(); Trc_OMR_Test_String(vmthread, "Hello World!"); Trc_OMR_Test_Ptr(vmthread, vmthread); Trc_OMR_Test_Int(vmthread, 10); Trc_OMR_Test_ManyParms(vmthread, "Hello again!", vmthread, 10); /* Fire some trace points in another thread. */ OMRTEST_ASSERT_ERROR_NONE(startTestChildThread(&testVM, vmthread, &childThread, &childData)); OMRTEST_ASSERT_ERROR_NONE(waitForTestChildThread(&testVM, childThread, childData)); /* Confirm that the test worked! */ /* OMRTODO Check something */ UT_OMR_TEST_MODULE_UNLOADED(testVM.omrVM._trcEngine->utIntf); #if TEST_TRACEAGENT /* Unload the traceagent */ OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnUnload(agent)); omr_agent_destroy(agent); #endif /* TEST_TRACEAGENT */ /* Load sampleSubscriber agent */ #if defined(WIN32) agent = omr_agent_create(&testVM.omrVM, "sampleSubscriber=NUL"); #else /* defined(WIN32) */ agent = omr_agent_create(&testVM.omrVM, "sampleSubscriber=/dev/null"); #endif /* defined(WIN32) */ ASSERT_FALSE(NULL == agent) << "testAgent: createAgent() sampleSubscriber failed"; OMRTEST_ASSERT_ERROR_NONE(omr_agent_openLibrary(agent)); OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnLoad(agent)); OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnUnload(agent)); omr_agent_destroy(agent); /* Load bindthreadagent agent */ agent = omr_agent_create(&testVM.omrVM, "bindthreadagent"); ASSERT_FALSE(NULL == agent) << "testAgent: createAgent() bindthreadagent failed"; OMRTEST_ASSERT_ERROR_NONE(omr_agent_openLibrary(agent)); OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnLoad(agent)); OMRTEST_ASSERT_ERROR_NONE(omr_agent_callOnUnload(agent)); omr_agent_destroy(agent); OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread)); OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread)); /* Now clear up the VM we started for this test case. */ OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM)); }