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));
}
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));
}
virtual void
SetUp()
{
OMRTEST_ASSERT_ERROR_NONE(omrTestVMInit(&testVM, rasTestEnv->getPortLibrary()));
#if defined(WIN32)
/* initialize sockets so that we can use gethostname() */
WORD wsaVersionRequested = MAKEWORD(2, 2);
WSADATA wsaData;
int wsaErr = WSAStartup(wsaVersionRequested, &wsaData);
ASSERT_EQ(0, wsaErr);
#endif /* defined(WIN32) */
}
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));
}