static DECLCALLBACK(int) testSessionWaitThread(RTTHREAD hSelf, void *pvUser)
{
PLOCALIPCTHREADCTX pCtx = (PLOCALIPCTHREADCTX)pvUser;
AssertPtr(pCtx);
int rc;
for (;;)
{
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionWaitThread: Listening for incoming connections ...\n");
RTLOCALIPCSESSION ipcSession;
rc = RTLocalIpcServerListen(pCtx->hServer, &ipcSession);
if (RT_SUCCESS(rc))
{
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionWaitThread: Got new client connection, waiting a bit ...\n");
RTThreadSleep(2000);
rc = RTLocalIpcSessionClose(ipcSession);
}
else
{
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionWaitThread: Listening ended with rc=%Rrc\n", rc);
break;
}
}
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionWaitThread: Ended with rc=%Rrc\n", rc);
return rc;
}
static void doMemRealloc(RTTEST hTest)
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%u reallocation, grow by 1 bytes\n", PAGE_SIZE * 2);
size_t cbAlloc = RTRandS32Ex(1, _16K);
void *pvBuf = NULL;
RTTESTI_CHECK_RC_OK_RETV(RTMemSaferAllocZEx(&pvBuf, cbAlloc, 0));
for (uint32_t i = 0; i <= PAGE_SIZE * 2; i++)
{
cbAlloc += 1;
RTTESTI_CHECK_RC_OK_RETV(RTMemSaferReallocZEx(cbAlloc - 1, pvBuf, cbAlloc, &pvBuf, 0));
memset(pvBuf, i & 0x7f, cbAlloc);
}
RTMemSaferFree(pvBuf, cbAlloc);
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "100 random reallocations\n");
uint8_t chFiller = 0x42;
cbAlloc = 0;
pvBuf = NULL;
for (uint32_t i = 1; i <= 100; i++)
{
uint32_t cbNew = RTRandS32Ex(1, _16K + (i / 4) * _16K);
RTTESTI_CHECK_RC_OK_RETV(RTMemSaferReallocZEx(cbAlloc, pvBuf, cbNew, &pvBuf, 0));
RTTESTI_CHECK(ASMMemIsAll8(pvBuf, RT_MIN(cbAlloc, cbNew), chFiller) == NULL);
chFiller += 0x31;
memset(pvBuf, chFiller, cbNew);
cbAlloc = cbNew;
}
RTTESTI_CHECK_RC_OK_RETV(RTMemSaferReallocZEx(cbAlloc, pvBuf, 0, &pvBuf, 0));
RTTESTI_CHECK(pvBuf == NULL);
}
static void tstRTProcQueryUsername(void)
{
RTTestISub("Basics");
size_t cbUser;
char szUser[1024];
memset(szUser, '-', sizeof(szUser));
/* negative stuff that may assert: */
bool fMayPanic = RTAssertSetMayPanic(false);
bool fQuiet = RTAssertSetQuiet(true);
RTTESTI_CHECK_RC(RTProcQueryUsername(RTProcSelf(), NULL, 8, &cbUser), VERR_INVALID_PARAMETER);
RTTESTI_CHECK_RC(RTProcQueryUsername(RTProcSelf(), szUser, 0, &cbUser), VERR_INVALID_PARAMETER);
RTTESTI_CHECK_RC(RTProcQueryUsername(RTProcSelf(), NULL, 0, NULL), VERR_INVALID_PARAMETER);
RTTESTI_CHECK_RC(RTProcQueryUsernameA(RTProcSelf(), NULL), VERR_INVALID_POINTER);
RTAssertSetMayPanic(fMayPanic);
RTAssertSetQuiet(fQuiet);
RTTESTI_CHECK_RC(RTProcQueryUsername(RTProcSelf(), NULL, 0, &cbUser), VERR_BUFFER_OVERFLOW);
memset(szUser, '-', sizeof(szUser));
RTTESTI_CHECK_RC(RTProcQueryUsername(RTProcSelf(), szUser, cbUser - 1, &cbUser), VERR_BUFFER_OVERFLOW);
memset(szUser, '-', sizeof(szUser));
RTTESTI_CHECK_RC(RTProcQueryUsername(RTProcSelf(), szUser, sizeof(szUser), &cbUser), VINF_SUCCESS);
RTTestPrintf(NULL, RTTESTLVL_ALWAYS, "Username: %s\n", szUser); /* */
char *pszUser = NULL;
RTTESTI_CHECK_RC(RTProcQueryUsernameA(RTProcSelf(), &pszUser), VINF_SUCCESS);
RTTestPrintf(NULL, RTTESTLVL_ALWAYS, "Username: %s\n", pszUser);
RTTESTI_CHECK(strcmp(pszUser, szUser) == 0);
RTStrFree(pszUser);
}
int main(int argc, char **argv)
{
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitExAndCreate(argc, &argv, 0 /*fRtInit*/, "tstRTIsoFs", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
if (argc <= 1)
return RTTestSkipAndDestroy(hTest, "no input");
/*
* First argument is the ISO to open.
*/
RTISOFSFILE IsoFs;
int rc = RTIsoFsOpen(&IsoFs, argv[1]);
if (RT_SUCCESS(rc))
{
/*
* Remaining arguments specifies files in the ISO that we wish information
* about and optionally extract.
*/
for (int i = 2; i < argc; i++)
{
char *pszFile = argv[i];
char chSaved = 0;
char *pszDst = strchr(pszFile, '=');
if (pszDst)
{
chSaved = *pszDst;
*pszDst = '\0';
}
uint32_t offFile = UINT32_MAX / 2;
size_t cbFile = UINT32_MAX / 2;
rc = RTIsoFsGetFileInfo(&IsoFs, pszFile, &offFile, &cbFile);
if (RT_SUCCESS(rc))
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%s: %u bytes at %#x\n", pszFile, (uint32_t)cbFile, offFile);
if (pszDst)
{
rc = RTIsoFsExtractFile(&IsoFs, pszFile, pszDst);
if (RT_SUCCESS(rc))
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%s: saved as '%s'.\n", pszFile, pszDst);
else
RTTestFailed(hTest, "RTIsoFsExtractFile failed to extract '%s' to '%s': %Rrc", pszFile, pszDst, rc);
}
}
else
RTTestFailed(hTest, "RTIsoFsGetFileInfo failed for '%s': %Rrc", pszFile, rc);
if (pszDst)
pszDst[-1] = chSaved;
}
RTIsoFsClose(&IsoFs);
}
else
RTTestFailed(hTest, "RTIsoFsOpen failed to open '%s': %Rrc", argv[1], rc);
return RTTestSummaryAndDestroy(hTest);
}
int main(int argc, char **argv)
{
RT_NOREF_PV(argv);
int rc = RTTestInitAndCreate("tstRTCritSectRw", &g_hTest);
if (rc)
return 1;
RTTestBanner(g_hTest);
if (Test1())
{
RTCPUID cCores = RTMpGetOnlineCoreCount();
if (argc == 1)
{
TestNegative();
/* threads, seconds, writePercent, yield, quiet */
Test4( 1, 1, 0, true, false);
Test4( 1, 1, 1, true, false);
Test4( 1, 1, 5, true, false);
Test4( 2, 1, 3, true, false);
Test4( 10, 1, 5, true, false);
Test4( 10, 10, 10, false, false);
if (cCores > 1)
{
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking (%u CPU cores)...\n", cCores);
for (unsigned cThreads = 1; cThreads < 32; cThreads++)
Test4(cThreads, 2, 1, false, true);
}
else
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "skipping benchmarking (only %u core available)\n", cCores);
/** @todo add a testcase where some stuff times out. */
}
else
{
if (cCores > 1)
{
/* threads, seconds, writePercent, yield, quiet */
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking (%u CPU cores)...\n", cCores);
Test4( 1, 3, 1, false, true);
Test4( 1, 3, 1, false, true);
Test4( 1, 3, 1, false, true);
Test4( 2, 3, 1, false, true);
Test4( 2, 3, 1, false, true);
Test4( 2, 3, 1, false, true);
Test4( 3, 3, 1, false, true);
Test4( 3, 3, 1, false, true);
Test4( 3, 3, 1, false, true);
}
else
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "skipping benchmarking (only %u core available)\n", cCores);
}
}
return RTTestSummaryAndDestroy(g_hTest);
}
static int testSessionWait(RTTEST hTest, const char *pszExecPath)
{
RTTestSub(hTest, "testSessionWait");
RTLOCALIPCSERVER ipcServer;
int rc = RTLocalIpcServerCreate(&ipcServer, "tstRTLocalIpcSessionWait",
RTLOCALIPC_FLAGS_MULTI_SESSION);
if (RT_SUCCESS(rc))
{
LOCALIPCTHREADCTX threadCtx = { ipcServer, hTest };
/* Spawn a simple worker thread and let it listen for incoming connections.
* In the meanwhile we try to cancel the server and see what happens. */
RTTHREAD hThread;
rc = RTThreadCreate(&hThread, testSessionWaitThread,
&threadCtx, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc3");
if (RT_SUCCESS(rc))
{
do
{
RTPROCESS hProc;
const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionWaitFork", NULL };
RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs,
RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
RTThreadSleep(5000); /* Let the server run for some time ... */
RTTestPrintf(hTest, RTTESTLVL_INFO, "Cancelling server listening\n");
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS);
/* Wait for the server thread to terminate. */
int threadRc;
RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
30 * 1000 /* 30s timeout */, &threadRc), VINF_SUCCESS);
RTTEST_CHECK_RC_BREAK(hTest, threadRc, VERR_CANCELLED);
RTTEST_CHECK_RC(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "Server thread terminated successfully\n");
/* Check if the child ran successfully. */
RTPROCSTATUS stsChild;
RTTEST_CHECK_RC_BREAK(hTest, RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &stsChild), VINF_SUCCESS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "Child terminated\n");
RTTEST_CHECK_BREAK(hTest, stsChild.enmReason == RTPROCEXITREASON_NORMAL);
RTTEST_CHECK_BREAK(hTest, stsChild.iStatus == 0);
}
while (0);
}
else
RTTestFailed(hTest, "Unable to create thread for cancelling server, rc=%Rrc\n", rc);
}
else
RTTestFailed(hTest, "Unable to create IPC server, rc=%Rrc\n", rc);
return VINF_SUCCESS;
}
static int testSessionDataThreadWorker(PLOCALIPCTHREADCTX pCtx)
{
AssertPtr(pCtx);
size_t cbScratchBuf = _1K; /** @todo Make this random in future. */
uint8_t *pvScratchBuf = (uint8_t*)RTMemAlloc(cbScratchBuf);
RTTEST_CHECK_RET(pCtx->hTest, pvScratchBuf != NULL, VERR_NO_MEMORY);
do
{
/* Note: At the moment we only support one client per run. */
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionDataThread: Listening for incoming connections ...\n");
RTLOCALIPCSESSION hSession;
RTTEST_CHECK_RC_BREAK(pCtx->hTest, RTLocalIpcServerListen(pCtx->hServer, &hSession), VINF_SUCCESS);
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionDataThread: Got new client connection\n");
uint32_t cRounds = 256; /** @todo Use RTRand(). */
/* Write how many rounds we're going to send data. */
RTTEST_CHECK_RC_BREAK(pCtx->hTest, RTLocalIpcSessionWrite(hSession, &cRounds, sizeof(cRounds)), VINF_SUCCESS);
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionDataThread: Written number of rounds\n");
for (uint32_t i = 0; i < cRounds; i++)
{
LOCALIPCTESTMSG msg;
RTTEST_CHECK_BREAK(pCtx->hTest, RTStrPrintf(msg.szOp, sizeof(msg.szOp),
"YayIGotRound%RU32FromTheServer", i) > 0);
RTTEST_CHECK_RC_BREAK(pCtx->hTest, RTLocalIpcSessionWrite(hSession, &msg, sizeof(msg)), VINF_SUCCESS);
}
if (!RTTestErrorCount(pCtx->hTest))
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionDataThread: Data successfully written\n");
/* Try to receive the same amount of rounds from the client. */
for (uint32_t i = 0; i < cRounds; i++)
{
RTTEST_CHECK_RC_BREAK(pCtx->hTest, RTLocalIpcSessionWaitForData(hSession, RT_INDEFINITE_WAIT),
VINF_SUCCESS);
char szMsg[32];
RTTEST_CHECK_BREAK(pCtx->hTest, RTStrPrintf(szMsg, sizeof(szMsg), "YayIGotRound%RU32FromTheClient", i) > 0);
RTTEST_CHECK_RC_BREAK(pCtx->hTest, testSessionDataReadTestMsg(pCtx->hTest, hSession,
pvScratchBuf, cbScratchBuf,
szMsg), VINF_SUCCESS);
if (RTTestErrorCount(pCtx->hTest))
break;
}
if (!RTTestErrorCount(pCtx->hTest))
RTTestPrintf(pCtx->hTest, RTTESTLVL_INFO, "testSessionDataThread: Data successfully read\n");
RTTEST_CHECK_RC_BREAK(pCtx->hTest, RTLocalIpcSessionClose(hSession), VINF_SUCCESS);
} while (0);
RTMemFree(pvScratchBuf);
return !RTTestErrorCount(pCtx->hTest) ? VINF_SUCCESS : VERR_GENERAL_FAILURE /* Doesn't matter */;
}
/**
* Write (output).
*
* @returns VBox status code.
* @param pBack Pointer to the backend structure supplied by
* the backend. The backend can use this to find
* it's instance data.
* @param pvBuf What to write.
* @param cbBuf Number of bytes to write.
* @param pcbWritten Where to store the number of bytes actually written.
* If NULL the entire buffer must be successfully written.
*/
static DECLCALLBACK(int) tstDBGCBackWrite(PDBGCBACK pBack, const void *pvBuf, size_t cbBuf, size_t *pcbWritten)
{
const char *pch = (const char *)pvBuf;
if (pcbWritten)
*pcbWritten = cbBuf;
while (cbBuf-- > 0)
{
/* screen/log output */
if (g_fPendingPrefix)
{
RTTestPrintfNl(g_hTest, RTTESTLVL_ALWAYS, "OUTPUT: ");
g_fPendingPrefix = false;
}
if (*pch == '\n')
g_fPendingPrefix = true;
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "%c", *pch);
/* buffer output */
if (g_offOutput < sizeof(g_szOutput) - 1)
{
g_szOutput[g_offOutput++] = *pch;
g_szOutput[g_offOutput] = '\0';
}
/* advance */
pch++;
}
return VINF_SUCCESS;
}
int main(int argc, char **argv)
{
int rc = RTTestInitAndCreate("tstRTSemRW", &g_hTest);
if (rc)
return 1;
RTTestBanner(g_hTest);
if (Test1())
{
if (argc == 1)
{
Test2();
Test3();
/* threads, seconds, writePercent, yield, quiet */
Test4( 1, 1, 0, true, false);
Test4( 1, 1, 1, true, false);
Test4( 1, 1, 5, true, false);
Test4( 2, 1, 3, true, false);
Test4( 10, 1, 5, true, false);
Test4( 10, 10, 10, false, false);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking...\n");
for (unsigned cThreads = 1; cThreads < 32; cThreads++)
Test4(cThreads, 2, 1, false, true);
/** @todo add a testcase where some stuff times out. */
}
else
{
/* threads, seconds, writePercent, yield, quiet */
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking...\n");
Test4( 1, 3, 1, false, true);
Test4( 1, 3, 1, false, true);
Test4( 1, 3, 1, false, true);
Test4( 2, 3, 1, false, true);
Test4( 2, 3, 1, false, true);
Test4( 2, 3, 1, false, true);
Test4( 3, 3, 1, false, true);
Test4( 3, 3, 1, false, true);
Test4( 3, 3, 1, false, true);
}
}
return RTTestSummaryAndDestroy(g_hTest);
}
int main(int argc, char **argv)
{
/*
* Init RT+Test.
*/
RTTEST hTest;
int rc = RTTestInitExAndCreate(argc, &argv, 0, "tstRTPathGlob", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
if (argc <= 1)
return RTTestSkipAndDestroy(hTest, "Requires arguments");
/*
* Manual glob testing.
*/
for (int i = 1; i < argc; i++)
{
uint32_t cResults = UINT32_MAX;
PCRTPATHGLOBENTRY pHead = (PCRTPATHGLOBENTRY)&cResults;
rc = RTPathGlob(argv[i], 0, &pHead, &cResults);
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "#%u '%s' -> %Rrc cResult=%u\n", i, argv[i], rc, cResults);
if (RT_SUCCESS(rc))
{
uint32_t iEntry = 0;
for (PCRTPATHGLOBENTRY pCur = pHead; pCur; pCur = pCur->pNext, iEntry++)
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, " #%3u: '%s'\n", iEntry, pCur->szPath);
RTTEST_CHECK(hTest, strlen(pCur->szPath) == pCur->cchPath);
}
RTPathGlobFree(pHead);
}
}
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
/**
* Send thread.
* This is constantly sending frames to the other interface.
*/
DECLCALLBACK(int) SendThread(RTTHREAD Thread, void *pvArg)
{
PMYARGS pArgs = (PMYARGS)pvArg;
int rc;
/*
* Send g_cbTransfer of data.
*/
uint8_t abBuf[16384] = {0};
MYFRAMEHDR *pHdr = (MYFRAMEHDR *)&abBuf[0];
uint32_t iFrame = 0;
uint32_t cbSent = 0;
uint32_t cSend = 0;
pHdr->SrcMac = pArgs->Mac;
pHdr->DstMac = pArgs->Mac;
pHdr->DstMac.au16[2] = (pArgs->Mac.au16[2] + 1) % 2;
pArgs->u64Start = RTTimeNanoTS();
for (; cbSent < g_cbTransfer; iFrame++)
{
const unsigned cb = pArgs->cbFrame
? pArgs->cbFrame
: iFrame % 1519 + sizeof(RTMAC) * 2 + sizeof(unsigned);
pHdr->iFrame = iFrame;
INTNETSG Sg;
IntNetSgInitTemp(&Sg, abBuf, cb);
RTTEST_CHECK_RC_OK(g_hTest, rc = intnetR0RingWriteFrame(&pArgs->pBuf->Send, &Sg, NULL));
if (RT_SUCCESS(rc))
RTTEST_CHECK_RC_OK(g_hTest, rc = IntNetR0IfSend(pArgs->hIf, g_pSession));
cbSent += cb;
}
/*
* Termination frames.
*/
pHdr->iFrame = 0xffffdead;
pHdr->auEos[0] = 0xffffdead;
pHdr->auEos[1] = 0xffffdead;
pHdr->auEos[2] = 0xffffdead;
for (unsigned c = 0; c < 20; c++)
{
RTTEST_CHECK_RC_OK(g_hTest, rc = tstIntNetSendBuf(&pArgs->pBuf->Send, pArgs->hIf, g_pSession,
abBuf, sizeof(RTMAC) * 2 + sizeof(unsigned) * 4));
RTThreadSleep(1);
}
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"sender thread %.6Rhxs terminating.\n"
"iFrame=%u cb=%'u\n",
&pArgs->Mac, iFrame, cbSent);
return 0;
}
/**
* Formalities...
*/
int main()
{
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitAndCreate("tstIEMCheckMc", &hTest);
if (rcExit == RTEXITCODE_SUCCESS)
{
RTTestBanner(hTest);
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "(this is only a compile test.)");
rcExit = RTTestSummaryAndDestroy(hTest);
}
return rcExit;
}
int main(int argc, char *argv[])
{
/*
* Init IPRT and globals.
*/
int rc = RTTestInitAndCreate("UsbTest", &g_hTest);
if (rc)
return rc;
/*
* Default values.
*/
const char *pszDevice = NULL;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, g_aCmdOptions, RT_ELEMENTS(g_aCmdOptions), 1, 0 /* fFlags */);
while ((rc = RTGetOpt(&GetState, &ValueUnion)))
{
switch (rc)
{
case 'h':
usbTestUsage(g_pStdOut);
return RTEXITCODE_SUCCESS;
case 'd':
pszDevice = ValueUnion.psz;
break;
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
/*
* Start testing.
*/
RTTestBanner(g_hTest);
/* Find the first test device if none was given. */
if (!pszDevice)
pszDevice = usbTestFindDevice();
if (pszDevice)
usbTestExec(pszDevice);
else
{
RTTestPrintf(g_hTest, RTTESTLVL_FAILURE, "Failed to find a test device\n");
RTTestErrorInc(g_hTest);
}
RTEXITCODE rcExit = RTTestSummaryAndDestroy(g_hTest);
return rcExit;
}
int main(int argc, char **argv)
{
/*
* Initialize IPRT and create the test.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTDvm", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* If no args, display usage.
*/
if (argc < 2)
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Syntax: %s <image>\n", argv[0]);
return RTTestSkipAndDestroy(hTest, "Missing required arguments\n");
}
/* Open image. */
RTFILE hFile;
uint64_t cb = 0;
rc = RTFileOpen(&hFile, argv[1], RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_READWRITE);
if (RT_FAILURE(rc))
{
RTTestIFailed("RTFileOpen -> %Rrc", rc);
return RTTestSummaryAndDestroy(hTest);
}
rc = RTFileGetSize(hFile, &cb);
if ( RT_FAILURE(rc)
|| cb % 512 != 0) /* Assume 512 byte sector size. */
{
RTTestIFailed("RTFileGetSize -> %Rrc", rc);
return RTTestSummaryAndDestroy(hTest);
}
TSTRTDVMDISK Disk;
Disk.fUseImage = true;
Disk.hImage = hFile;
rc = tstRTDvmVolume(hTest, &Disk, cb, 0);
RTTESTI_CHECK(rc == VINF_SUCCESS);
/*
* Summary
*/
return RTTestSummaryAndDestroy(hTest);
}
static int testServerListenAndCancel(RTTEST hTest, const char *pszExecPath)
{
RTTestSub(hTest, "testServerListenAndCancel");
RTLOCALIPCSERVER ipcServer;
int rc = RTLocalIpcServerCreate(&ipcServer, "testServerListenAndCancel",
RTLOCALIPC_FLAGS_MULTI_SESSION);
if (RT_SUCCESS(rc))
{
/* Spawn a simple worker thread and let it listen for incoming connections.
* In the meanwhile we try to cancel the server and see what happens. */
RTTHREAD hThread;
rc = RTThreadCreate(&hThread, testServerListenAndCancelThread,
&ipcServer, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc1");
if (RT_SUCCESS(rc))
{
do
{
RTTestPrintf(hTest, RTTESTLVL_INFO, "Listening for incoming connections ...\n");
RTLOCALIPCSESSION ipcSession;
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerListen(ipcServer, &ipcSession), VERR_CANCELLED);
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS);
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "Waiting for thread to exit ...\n");
RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
30 * 1000 /* 30s timeout */, NULL), VINF_SUCCESS);
} while (0);
}
else
RTTestIFailed("Unable to create thread for cancelling server, rc=%Rrc\n", rc);
}
else
RTTestIFailed("Unable to create IPC server, rc=%Rrc\n", rc);
return VINF_SUCCESS;
}
int main(int argc, char **argv)
{
/*
* Initialize IPRT and create the test.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTFilesystem", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* If no args, display usage.
*/
if (argc < 2)
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Syntax: %s <image>\n", argv[0]);
return RTTestSkipAndDestroy(hTest, "Missing required arguments\n");
}
/* Open image. */
RTFILE hFile;
RTVFSFILE hVfsFile;
rc = RTFileOpen(&hFile, argv[1], RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_READ);
if (RT_FAILURE(rc))
{
RTTestIFailed("RTFileOpen -> %Rrc", rc);
return RTTestSummaryAndDestroy(hTest);
}
rc = RTVfsFileFromRTFile(hFile, 0, false, &hVfsFile);
if (RT_FAILURE(rc))
{
RTTestIFailed("RTVfsFileFromRTFile -> %Rrc", rc);
return RTTestSummaryAndDestroy(hTest);
}
rc = tstRTFilesystem(hTest, hVfsFile);
RTTESTI_CHECK(rc == VINF_SUCCESS);
RTVfsFileRelease(hVfsFile);
/*
* Summary
*/
return RTTestSummaryAndDestroy(hTest);
}
int main()
{
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitAndCreate("tstRTMemSafer", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(hTest);
#ifdef VBOX
SUPR3Init(NULL);
#endif
/*
* Not using sub-tests here, just printing progress.
*/
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "20 random allocations\n");
for (uint32_t i = 0; i < 20; i++)
doMemSaferAllocation(hTest);
doMemRealloc(hTest);
return RTTestSummaryAndDestroy(hTest);
}
static void doMemWipeThoroughly(RTTEST hTest)
{
for (uint32_t p = 0; p < RTRandU32Ex(1, 64); p++)
{
size_t cbAlloc = RTRandS32Ex(1, _1M) * sizeof(uint8_t);
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Testing wipe #%.02RU32 (%u bytes) ...\n",
p + 1, cbAlloc);
void *pvBuf = RTMemAlloc(cbAlloc);
if (!pvBuf)
{
RTTestIFailed("No memory for first buffer (%z bytes)\n",
cbAlloc);
continue;
}
RTRandBytes(pvBuf, cbAlloc);
void *pvWipe = RTMemDup(pvBuf, cbAlloc);
if (!pvWipe)
{
RTMemFree(pvBuf);
RTTestIFailed("No memory for second buffer (%z bytes)\n",
cbAlloc);
continue;
}
size_t cbWipeRand = RTRandU32Ex(1, cbAlloc);
RTMemWipeThoroughly(pvWipe, RT_MIN(cbAlloc, cbWipeRand), p /* Passes */);
if (!memcmp(pvWipe, pvBuf, cbAlloc))
RTTestIFailed("Memory blocks must differ (%z bytes, 0x%p vs. 0x%p)!\n",
cbAlloc, pvWipe, pvBuf);
RTMemFree(pvWipe);
RTMemFree(pvBuf);
}
}
int main()
{
/*
* Init.
*/
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitExAndCreate(0, NULL, RTR3INIT_FLAGS_SUPLIB, "tstRTTime", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(hTest);
/*
* RTNanoTimeTS() shall never return something which
* is less or equal to the return of the previous call.
*/
RTTimeSystemNanoTS(); RTTimeNanoTS(); RTThreadYield();
uint64_t u64RTStartTS = RTTimeNanoTS();
uint64_t u64OSStartTS = RTTimeSystemNanoTS();
uint32_t i;
uint64_t u64Prev = RTTimeNanoTS();
for (i = 0; i < 100*_1M; i++)
{
uint64_t u64 = RTTimeNanoTS();
if (u64 <= u64Prev)
{
/** @todo wrapping detection. */
RTTestFailed(hTest, "i=%#010x u64=%#llx u64Prev=%#llx (1)\n", i, u64, u64Prev);
if (RTTestErrorCount(hTest) >= 256)
break;
RTThreadYield();
u64 = RTTimeNanoTS();
}
else if (u64 - u64Prev > 1000000000 /* 1sec */)
{
RTTestFailed(hTest, "i=%#010x u64=%#llx u64Prev=%#llx delta=%lld\n", i, u64, u64Prev, u64 - u64Prev);
if (RTTestErrorCount(hTest) >= 256)
break;
RTThreadYield();
u64 = RTTimeNanoTS();
}
if (!(i & (_1M*2 - 1)))
{
RTTestPrintf(hTest, RTTESTLVL_INFO, "i=%#010x u64=%#llx u64Prev=%#llx delta=%lld\n", i, u64, u64Prev, u64 - u64Prev);
RTThreadYield();
u64 = RTTimeNanoTS();
}
u64Prev = u64;
}
RTTimeSystemNanoTS(); RTTimeNanoTS(); RTThreadYield();
uint64_t u64RTElapsedTS = RTTimeNanoTS();
uint64_t u64OSElapsedTS = RTTimeSystemNanoTS();
u64RTElapsedTS -= u64RTStartTS;
u64OSElapsedTS -= u64OSStartTS;
int64_t i64Diff = u64OSElapsedTS >= u64RTElapsedTS ? u64OSElapsedTS - u64RTElapsedTS : u64RTElapsedTS - u64OSElapsedTS;
if (i64Diff > (int64_t)(u64OSElapsedTS / 1000))
RTTestFailed(hTest, "total time differs too much! u64OSElapsedTS=%#llx u64RTElapsedTS=%#llx delta=%lld\n",
u64OSElapsedTS, u64RTElapsedTS, u64OSElapsedTS - u64RTElapsedTS);
else
{
if (u64OSElapsedTS >= u64RTElapsedTS)
RTTestValue(hTest, "Total time delta", u64OSElapsedTS - u64RTElapsedTS, RTTESTUNIT_NS);
else
RTTestValue(hTest, "Total time delta", u64RTElapsedTS - u64OSElapsedTS, RTTESTUNIT_NS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "total time difference: u64OSElapsedTS=%#llx u64RTElapsedTS=%#llx delta=%lld\n",
u64OSElapsedTS, u64RTElapsedTS, u64OSElapsedTS - u64RTElapsedTS);
}
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) /** @todo This isn't really x86 or AMD64 specific... */
RTTestValue(hTest, "RTTimeDbgSteps", RTTimeDbgSteps(), RTTESTUNIT_OCCURRENCES);
RTTestValue(hTest, "RTTimeDbgSteps pp", ((uint64_t)RTTimeDbgSteps() * 1000) / i, RTTESTUNIT_PP1K);
RTTestValue(hTest, "RTTimeDbgExpired", RTTimeDbgExpired(), RTTESTUNIT_OCCURRENCES);
RTTestValue(hTest, "RTTimeDbgExpired pp", ((uint64_t)RTTimeDbgExpired() * 1000) / i, RTTESTUNIT_PP1K);
RTTestValue(hTest, "RTTimeDbgBad", RTTimeDbgBad(), RTTESTUNIT_OCCURRENCES);
RTTestValue(hTest, "RTTimeDbgBad pp", ((uint64_t)RTTimeDbgBad() * 1000) / i, RTTESTUNIT_PP1K);
RTTestValue(hTest, "RTTimeDbgRaces", RTTimeDbgRaces(), RTTESTUNIT_OCCURRENCES);
RTTestValue(hTest, "RTTimeDbgRaces pp", ((uint64_t)RTTimeDbgRaces() * 1000) / i, RTTESTUNIT_PP1K);
#endif
return RTTestSummaryAndDestroy(hTest);
}
static DECLCALLBACK(int) Test4Thread(RTTHREAD ThreadSelf, void *pvUser)
{
/* Use randomization to get a little more variation of the sync pattern.
We use a pseudo random generator here so that we don't end up testing
the speed of the /dev/urandom implementation, but rather the read-write
semaphores. */
int rc;
RTRAND hRand;
RTTEST_CHECK_RC_OK_RET(g_hTest, rc = RTRandAdvCreateParkMiller(&hRand), rc);
RTTEST_CHECK_RC_OK_RET(g_hTest, rc = RTRandAdvSeed(hRand, (uintptr_t)ThreadSelf), rc);
unsigned c100 = RTRandAdvU32Ex(hRand, 0, 99);
uint64_t *pcItr = (uint64_t *)pvUser;
bool fWrite;
for (;;)
{
unsigned readrec = RTRandAdvU32Ex(hRand, 0, 3);
unsigned writerec = RTRandAdvU32Ex(hRand, 0, 3);
/* Don't overdo recursion testing. */
if (readrec > 1)
readrec--;
if (writerec > 1)
writerec--;
fWrite = (c100 < g_uWritePercent);
if (fWrite)
{
for (unsigned i = 0; i <= writerec; i++)
{
rc = RTCritSectRwEnterExcl(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Write recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
if (RT_FAILURE(rc))
break;
if (ASMAtomicIncU32(&g_cConcurrentWriters) != 1)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after write locking it",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
if (g_cConcurrentReaders != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s after write locking it",
g_cConcurrentReaders, RTThreadSelfName());
break;
}
}
else
{
rc = RTCritSectRwEnterShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read locking on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
break;
}
ASMAtomicIncU32(&g_cConcurrentReaders);
if (g_cConcurrentWriters != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after read locking it",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
}
for (unsigned i = 0; i < readrec; i++)
{
rc = RTCritSectRwEnterShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
if (RT_FAILURE(rc))
break;
/*
* Check for fairness: The values of the threads should not differ too much
*/
(*pcItr)++;
/*
* Check for correctness: Give other threads a chance. If the implementation is
* correct, no other thread will be able to enter this lock now.
*/
if (g_fYield)
RTThreadYield();
for (unsigned i = 0; i < readrec; i++)
{
rc = RTCritSectRwLeaveShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
if (RT_FAILURE(rc))
break;
if (fWrite)
{
if (ASMAtomicDecU32(&g_cConcurrentWriters) != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before write release",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
if (g_cConcurrentReaders != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s before write release",
g_cConcurrentReaders, RTThreadSelfName());
break;
}
for (unsigned i = 0; i <= writerec; i++)
{
rc = RTCritSectRwLeaveExcl(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Write release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
}
else
{
if (g_cConcurrentWriters != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before read release",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
ASMAtomicDecU32(&g_cConcurrentReaders);
rc = RTCritSectRwLeaveShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read release on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
break;
}
}
if (g_fTerminate)
break;
c100++;
c100 %= 100;
}
if (!g_fQuiet)
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Thread %s exited with %lld\n", RTThreadSelfName(), *pcItr);
RTRandAdvDestroy(hRand);
return VINF_SUCCESS;
}
static void test1Worker(RTTEST hTest, const char *pszBaseDir,
const char *pszTarget, RTSYMLINKTYPE enmType, bool fDangling)
{
char szPath1[RTPATH_MAX];
char szPath2[RTPATH_MAX];
size_t cchTarget = strlen(pszTarget);
char szPath3[RTPATH_MAX];
RTStrCopy(szPath3, sizeof(szPath3), pszTarget);
#ifdef RT_OS_WINDOWS
/* see RTSymlinkCreate in symlink-win.cpp */
char c;
char *psz = szPath3;
while ((c = *psz) != '\0')
{
if (c == '/')
*psz = '\\';
psz++;
}
#endif
/* Create it.*/
RTTESTI_CHECK_RC_OK_RETV(RTPathJoin(szPath1, sizeof(szPath1), pszBaseDir, "tstRTSymlink-link-1"));
RTSymlinkDelete(szPath1, 0); /* clean up previous run */
int rc = RTSymlinkCreate(szPath1, pszTarget, RTSYMLINKTYPE_FILE, 0);
if (rc == VERR_NOT_SUPPORTED)
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "VERR_NOT_SUPPORTED - skipping\n");
return;
}
RTTESTI_CHECK_RC_RETV(rc, VINF_SUCCESS);
/* Check the predicate functions. */
RTTESTI_CHECK(RTSymlinkExists(szPath1));
RTTESTI_CHECK(RTSymlinkIsDangling(szPath1) == fDangling);
/* Read it. */
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, sizeof(szPath2), 0), VINF_SUCCESS);
RTTESTI_CHECK_MSG(strcmp(szPath2, szPath3) == 0, ("got=\"%s\" expected=\"%s\"", szPath2, szPath3));
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, cchTarget + 1, 0), VINF_SUCCESS);
RTTESTI_CHECK_MSG(strcmp(szPath2, szPath3) == 0, ("got=\"%s\" expected=\"%s\"", szPath2, szPath3));
memset(szPath2, 0xff, sizeof(szPath2));
szPath2[sizeof(szPath2) - 1] = '\0';
RTTESTI_CHECK_RC(RTSymlinkRead(szPath1, szPath2, cchTarget, 0), VERR_BUFFER_OVERFLOW);
RTTESTI_CHECK_MSG( strncmp(szPath2, szPath3, cchTarget - 1) == 0
&& szPath2[cchTarget - 1] == '\0',
("got=\"%s\" expected=\"%.*s\"", szPath2, cchTarget - 1, szPath3));
/* Other APIs that have to handle symlinks carefully. */
RTFSOBJINFO ObjInfo;
RTTESTI_CHECK_RC(rc = RTPathQueryInfo(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
RTTESTI_CHECK_RC(rc = RTPathQueryInfoEx(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
if (!fDangling)
{
RTTESTI_CHECK_RC(rc = RTPathQueryInfoEx(szPath1, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK(!RTFS_IS_SYMLINK(ObjInfo.Attr.fMode));
else
RT_ZERO(ObjInfo);
if (enmType == RTSYMLINKTYPE_DIR)
{
RTTESTI_CHECK(RTDirExists(szPath1));
RTTESTI_CHECK(RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode));
}
else if (enmType == RTSYMLINKTYPE_FILE)
{
RTTESTI_CHECK(RTFileExists(szPath1));
RTTESTI_CHECK(RTFS_IS_FILE(ObjInfo.Attr.fMode));
}
/** @todo Check more APIs */
}
/* Finally, the removal of the symlink. */
RTTESTI_CHECK_RC(RTSymlinkDelete(szPath1, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTSymlinkDelete(szPath1, 0), VERR_FILE_NOT_FOUND);
}
static void Test4(unsigned cThreads, unsigned cSeconds, unsigned uWritePercent, bool fYield, bool fQuiet)
{
unsigned i;
uint64_t acIterations[32];
RTTHREAD aThreads[RT_ELEMENTS(acIterations)];
AssertRelease(cThreads <= RT_ELEMENTS(acIterations));
RTTestSubF(g_hTest, "Test4 - %u threads, %u sec, %u%% writes, %syielding",
cThreads, cSeconds, uWritePercent, fYield ? "" : "non-");
/*
* Init globals.
*/
g_fYield = fYield;
g_fQuiet = fQuiet;
g_fTerminate = false;
g_uWritePercent = uWritePercent;
g_cConcurrentWriters = 0;
g_cConcurrentReaders = 0;
RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectRwInit(&g_CritSectRw), VINF_SUCCESS);
/*
* Create the threads and let them block on the semrw.
*/
RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectRwEnterExcl(&g_CritSectRw), VINF_SUCCESS);
for (i = 0; i < cThreads; i++)
{
acIterations[i] = 0;
RTTEST_CHECK_RC_RETV(g_hTest, RTThreadCreateF(&aThreads[i], Test4Thread, &acIterations[i], 0,
RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE,
"test-%u", i), VINF_SUCCESS);
}
/*
* Do the test run.
*/
uint32_t cErrorsBefore = RTTestErrorCount(g_hTest);
uint64_t u64StartTS = RTTimeNanoTS();
RTTEST_CHECK_RC(g_hTest, RTCritSectRwLeaveExcl(&g_CritSectRw), VINF_SUCCESS);
RTThreadSleep(cSeconds * 1000);
ASMAtomicWriteBool(&g_fTerminate, true);
uint64_t ElapsedNS = RTTimeNanoTS() - u64StartTS;
/*
* Clean up the threads and semaphore.
*/
for (i = 0; i < cThreads; i++)
RTTEST_CHECK_RC(g_hTest, RTThreadWait(aThreads[i], 5000, NULL), VINF_SUCCESS);
RTTEST_CHECK_MSG(g_hTest, g_cConcurrentWriters == 0, (g_hTest, "g_cConcurrentWriters=%u at end of test\n", g_cConcurrentWriters));
RTTEST_CHECK_MSG(g_hTest, g_cConcurrentReaders == 0, (g_hTest, "g_cConcurrentReaders=%u at end of test\n", g_cConcurrentReaders));
RTTEST_CHECK_RC(g_hTest, RTCritSectRwDelete(&g_CritSectRw), VINF_SUCCESS);
if (RTTestErrorCount(g_hTest) != cErrorsBefore)
RTThreadSleep(100);
/*
* Collect and display the results.
*/
uint64_t cItrTotal = acIterations[0];
for (i = 1; i < cThreads; i++)
cItrTotal += acIterations[i];
uint64_t cItrNormal = cItrTotal / cThreads;
uint64_t cItrMinOK = cItrNormal / 20; /* 5% */
uint64_t cItrMaxDeviation = 0;
for (i = 0; i < cThreads; i++)
{
uint64_t cItrDelta = RT_ABS((int64_t)(acIterations[i] - cItrNormal));
if (acIterations[i] < cItrMinOK)
RTTestFailed(g_hTest, "Thread %u did less than 5%% of the iterations - %llu (it) vs. %llu (5%%) - %llu%%\n",
i, acIterations[i], cItrMinOK, cItrDelta * 100 / cItrNormal);
else if (cItrDelta > cItrNormal / 2)
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Warning! Thread %u deviates by more than 50%% - %llu (it) vs. %llu (avg) - %llu%%\n",
i, acIterations[i], cItrNormal, cItrDelta * 100 / cItrNormal);
if (cItrDelta > cItrMaxDeviation)
cItrMaxDeviation = cItrDelta;
}
//RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
// "Threads: %u Total: %llu Per Sec: %llu Avg: %llu ns Max dev: %llu%%\n",
// cThreads,
// cItrTotal,
// cItrTotal / cSeconds,
// ElapsedNS / cItrTotal,
// cItrMaxDeviation * 100 / cItrNormal
// );
//
RTTestValue(g_hTest, "Thruput", cItrTotal * UINT32_C(1000000000) / ElapsedNS, RTTESTUNIT_CALLS_PER_SEC);
RTTestValue(g_hTest, "Max diviation", cItrMaxDeviation * 100 / cItrNormal, RTTESTUNIT_PCT);
}
/**
* Do the bi-directional transfer test.
*/
static void tstBidirectionalTransfer(PTSTSTATE pThis, uint32_t cbFrame)
{
MYARGS Args0;
RT_ZERO(Args0);
Args0.hIf = pThis->hIf0;
Args0.pBuf = pThis->pBuf0;
Args0.Mac.au16[0] = 0x8086;
Args0.Mac.au16[1] = 0;
Args0.Mac.au16[2] = 0;
Args0.cbFrame = cbFrame;
MYARGS Args1;
RT_ZERO(Args1);
Args1.hIf = pThis->hIf1;
Args1.pBuf = pThis->pBuf1;
Args1.Mac.au16[0] = 0x8086;
Args1.Mac.au16[1] = 0;
Args1.Mac.au16[2] = 1;
Args1.cbFrame = cbFrame;
RTTHREAD ThreadRecv0 = NIL_RTTHREAD;
RTTHREAD ThreadRecv1 = NIL_RTTHREAD;
RTTHREAD ThreadSend0 = NIL_RTTHREAD;
RTTHREAD ThreadSend1 = NIL_RTTHREAD;
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadRecv0, ReceiveThread, &Args0, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "RECV0"));
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadRecv1, ReceiveThread, &Args1, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "RECV1"));
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadSend0, SendThread, &Args0, 0, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "SEND0"));
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadSend1, SendThread, &Args1, 0, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "SEND1"));
int rc2 = VINF_SUCCESS;
int rc;
RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadSend0, 5*60*1000, &rc2));
if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC_OK(rc2);
ThreadSend0 = NIL_RTTHREAD;
RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadSend1, 5*60*1000, RT_SUCCESS(rc2) ? &rc2 : NULL));
if (RT_SUCCESS(rc))
{
ThreadSend1 = NIL_RTTHREAD;
RTTESTI_CHECK_RC_OK(rc2);
}
}
if (RTTestErrorCount(g_hTest) == 0)
{
/*
* Wait a bit for the receivers to finish up.
*/
unsigned cYields = 100000;
while ( ( IntNetRingHasMoreToRead(&pThis->pBuf0->Recv)
|| IntNetRingHasMoreToRead(&pThis->pBuf1->Recv))
&& cYields-- > 0)
RTThreadYield();
uint64_t u64Elapsed = RT_MAX(Args0.u64End, Args1.u64End) - RT_MIN(Args0.u64Start, Args1.u64Start);
uint64_t u64Speed = (uint64_t)((2 * g_cbTransfer / 1024) / (u64Elapsed / 1000000000.0));
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"transferred %u bytes in %'RU64 ns (%'RU64 KB/s)\n",
2 * g_cbTransfer, u64Elapsed, u64Speed);
/*
* Wait for the threads to finish up...
*/
RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadRecv0, 5000, &rc2));
if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC_OK(rc2);
ThreadRecv0 = NIL_RTTHREAD;
}
RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadRecv1, 5000, &rc2));
if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC_OK(rc2);
ThreadRecv1 = NIL_RTTHREAD;
}
}
/*
* Give them a chance to complete...
*/
RTThreadWait(ThreadRecv0, 5000, NULL);
RTThreadWait(ThreadRecv1, 5000, NULL);
RTThreadWait(ThreadSend0, 5000, NULL);
RTThreadWait(ThreadSend1, 5000, NULL);
/*
* Display statistics.
*/
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf0: Yields-OK=%llu Yields-NOK=%llu Lost=%llu Bad=%llu\n",
pThis->pBuf0->cStatYieldsOk.c,
pThis->pBuf0->cStatYieldsNok.c,
pThis->pBuf0->cStatLost.c,
pThis->pBuf0->cStatBadFrames.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf0.Recv: Frames=%llu Bytes=%llu Overflows=%llu\n",
pThis->pBuf0->Recv.cStatFrames,
pThis->pBuf0->Recv.cbStatWritten.c,
pThis->pBuf0->Recv.cOverflows.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf0.Send: Frames=%llu Bytes=%llu Overflows=%llu\n",
pThis->pBuf0->Send.cStatFrames,
pThis->pBuf0->Send.cbStatWritten.c,
pThis->pBuf0->Send.cOverflows.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf1: Yields-OK=%llu Yields-NOK=%llu Lost=%llu Bad=%llu\n",
pThis->pBuf1->cStatYieldsOk.c,
pThis->pBuf1->cStatYieldsNok.c,
pThis->pBuf1->cStatLost.c,
pThis->pBuf1->cStatBadFrames.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf1.Recv: Frames=%llu Bytes=%llu Overflows=%llu\n",
pThis->pBuf1->Recv.cStatFrames,
pThis->pBuf1->Recv.cbStatWritten.c,
pThis->pBuf1->Recv.cOverflows.c);
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
"Buf1.Send: Frames=%llu Bytes=%llu Overflows=%llu\n",
pThis->pBuf1->Send.cStatFrames,
pThis->pBuf1->Send.cbStatWritten.c,
pThis->pBuf1->Send.cOverflows.c);
}
int main()
{
/*
* Init the runtime and stuff.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstFork", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
#ifdef RT_OS_WINDOWS
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Skipped\n");
#else
/*
* Get values that are supposed to or change across the fork.
*/
RTPROCESS const ProcBefore = RTProcSelf();
/*
* Fork.
*/
pid_t pid = fork();
if (pid == 0)
{
/*
* Check that the values has changed.
*/
rc = 0;
if (ProcBefore == RTProcSelf())
{
RTTestFailed(hTest, "%RTproc == %RTproc [child]", ProcBefore, RTProcSelf());
rc = 1;
}
return rc;
}
if (pid != -1)
{
/*
* Check that the values didn't change.
*/
RTTEST_CHECK(hTest, ProcBefore == RTProcSelf());
/*
* Wait for the child.
*/
rc = 1;
while ( waitpid(pid, &rc, 0)
&& errno == EINTR)
rc = 1;
if (!WIFEXITED(rc) || WEXITSTATUS(rc) != 0)
RTTestFailed(hTest, "rc=%#x", rc);
}
else
RTTestFailed(hTest, "fork() failed: %d - %s", errno, strerror(errno));
#endif
/*
* Summary
*/
return RTTestSummaryAndDestroy(hTest);
}
int main(int argc, char **argv)
{
RTEXITCODE rcExit = RTTestInitAndCreate("tstRTPrfIO", &g_hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(g_hTest);
/*
* Parse arguments
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--test-dir", 'd', RTGETOPT_REQ_STRING },
};
bool fFileOpenCloseTest = true;
bool fFileWriteByteTest = true;
bool fPathQueryInfoTest = true;
//bool fFileTests = true;
//bool fDirTests = true;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'd':
g_pszTestDir = ValueUnion.psz;
break;
case 'V':
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "$Revision$\n");
return RTTestSummaryAndDestroy(g_hTest);
case 'h':
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "usage: testname [-d <testdir>]\n");
return RTTestSummaryAndDestroy(g_hTest);
default:
RTTestFailed(g_hTest, "invalid argument");
RTGetOptPrintError(ch, &ValueUnion);
return RTTestSummaryAndDestroy(g_hTest);
}
}
/*
* Set up and check the prerequisites.
*/
RTTESTI_CHECK_RC(RTPathJoin(g_szTestFile1, sizeof(g_szTestFile1), g_pszTestDir, "tstRTPrfIO-TestFile1"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szTestDir1, sizeof(g_szTestDir1), g_pszTestDir, "tstRTPrfIO-TestDir1"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingFile, sizeof(g_szNotExitingFile), g_pszTestDir, "tstRTPrfIO-nonexistent-file"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingDir, sizeof(g_szNotExitingDir), g_pszTestDir, "tstRTPrfIO-nonexistent-dir"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingDirFile, sizeof(g_szNotExitingDirFile), g_szNotExitingDir, "nonexistent-file"), VINF_SUCCESS);
RTTESTI_CHECK(RTDirExists(g_pszTestDir));
if (RTPathExists(g_szTestDir1))
RTTestFailed(g_hTest, "The primary test directory (%s) already exist, please remove it", g_szTestDir1);
if (RTPathExists(g_szTestFile1))
RTTestFailed(g_hTest, "The primary test file (%s) already exist, please remove it", g_szTestFile1);
if (RTPathExists(g_szNotExitingFile))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingFile);
if (RTPathExists(g_szNotExitingDir))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingDir);
if (RTPathExists(g_szNotExitingDirFile))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingDirFile);
/*
* Do the testing.
*/
if (RTTestIErrorCount() == 0)
{
#if 1
if (fPathQueryInfoTest)
benchmarkPathQueryInfo();
if (fFileOpenCloseTest)
benchmarkFileOpenClose();
#endif
if (fFileWriteByteTest)
benchmarkFileWriteByte();
//if (fFileTests)
// benchmarkFile();
//if (fDirTests)
// benchmarkDir();
/*
* Cleanup.
*/
RTFileDelete(g_szTestFile1);
RTDirRemoveRecursive(g_szTestDir1, 0);
RTTESTI_CHECK(RTDirExists(g_pszTestDir));
RTTESTI_CHECK(!RTPathExists(g_szTestDir1));
RTTESTI_CHECK(!RTPathExists(g_szTestFile1));
}
return RTTestSummaryAndDestroy(g_hTest);
}
int main(int argc, char **argv)
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTUuid", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
#define CHECK_RC() \
do { if (RT_FAILURE(rc)) { RTTestFailed(hTest, "line %d: rc=%Rrc", __LINE__, rc); } } while (0)
RTTestSub(hTest, "RTUuidClear & RTUuisIsNull");
RTUUID UuidNull;
rc = RTUuidClear(&UuidNull); CHECK_RC();
RTTEST_CHECK(hTest, RTUuidIsNull(&UuidNull));
RTTEST_CHECK(hTest, RTUuidCompare(&UuidNull, &UuidNull) == 0);
RTTestSub(hTest, "RTUuidCreate");
RTUUID Uuid;
rc = RTUuidCreate(&Uuid); CHECK_RC();
RTTEST_CHECK(hTest, !RTUuidIsNull(&Uuid));
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid) == 0);
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &UuidNull) > 0);
RTTEST_CHECK(hTest, RTUuidCompare(&UuidNull, &Uuid) < 0);
RTTestSub(hTest, "RTUuidToStr");
char sz[RTUUID_STR_LENGTH];
rc = RTUuidToStr(&Uuid, sz, sizeof(sz)); CHECK_RC();
RTTEST_CHECK(hTest, strlen(sz) == RTUUID_STR_LENGTH - 1);
RTTestPrintf(hTest, RTTESTLVL_INFO, "UUID=%s\n", sz);
RTTestSub(hTest, "RTUuidFromStr");
RTUUID Uuid2;
rc = RTUuidFromStr(&Uuid2, sz); CHECK_RC();
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid2) == 0);
char *psz = (char *)RTTestGuardedAllocTail(hTest, RTUUID_STR_LENGTH);
if (psz)
{
RTStrPrintf(psz, RTUUID_STR_LENGTH, "%s", sz);
RTTESTI_CHECK_RC(RTUuidFromStr(&Uuid2, psz), VINF_SUCCESS);
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid2) == 0);
for (unsigned off = 1; off < RTUUID_STR_LENGTH; off++)
{
char *psz2 = psz + off;
RTStrPrintf(psz2, RTUUID_STR_LENGTH - off, "%s", sz);
RTTESTI_CHECK_RC(RTUuidFromStr(&Uuid2, psz2), VERR_INVALID_UUID_FORMAT);
}
RTTestGuardedFree(hTest, psz);
}
RTUuidClear(&Uuid2);
char sz2[RTUUID_STR_LENGTH + 2];
RTStrPrintf(sz2, sizeof(sz2), "{%s}", sz);
rc = RTUuidFromStr(&Uuid2, sz2); CHECK_RC();
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid2) == 0);
psz = (char *)RTTestGuardedAllocTail(hTest, RTUUID_STR_LENGTH + 2);
if (psz)
{
RTStrPrintf(psz, RTUUID_STR_LENGTH + 2, "{%s}", sz);
RTTESTI_CHECK_RC(RTUuidFromStr(&Uuid2, psz), VINF_SUCCESS);
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid2) == 0);
for (unsigned off = 1; off < RTUUID_STR_LENGTH + 2; off++)
{
char *psz2 = psz + off;
RTStrPrintf(psz2, RTUUID_STR_LENGTH + 2 - off, "{%s}", sz);
RTTESTI_CHECK_RC(RTUuidFromStr(&Uuid2, psz2), VERR_INVALID_UUID_FORMAT);
}
RTTestGuardedFree(hTest, psz);
}
RTTestSub(hTest, "RTUuidToUtf16");
RTUTF16 wsz[RTUUID_STR_LENGTH];
rc = RTUuidToUtf16(&Uuid, wsz, sizeof(wsz)); CHECK_RC();
RTTEST_CHECK(hTest, RTUtf16Len(wsz) == RTUUID_STR_LENGTH - 1);
RTTestSub(hTest, "RTUuidFromUtf16");
rc = RTUuidFromUtf16(&Uuid2, wsz); CHECK_RC();
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid2) == 0);
RTUTF16 *pwsz;
rc = RTStrToUtf16(sz2, &pwsz);
RTTEST_CHECK(hTest, rc == VINF_SUCCESS);
if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC(RTUuidFromUtf16(&Uuid2, pwsz), VINF_SUCCESS);
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid2) == 0);
RTUTF16 *pwsz2 = (RTUTF16*)RTTestGuardedAllocTail(hTest, 2 * (RTUUID_STR_LENGTH + 2));
if (pwsz2)
{
memcpy(pwsz2, pwsz, 2 * (RTUUID_STR_LENGTH + 2));
RTTESTI_CHECK_RC(RTUuidFromUtf16(&Uuid2, pwsz2), VINF_SUCCESS);
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid2) == 0);
for (unsigned off = 1; off < RTUUID_STR_LENGTH + 2; off++)
{
RTUTF16 *pwsz3 = pwsz2 + off;
memcpy(pwsz3, pwsz, 2 * (RTUUID_STR_LENGTH + 1 - off));
pwsz3[RTUUID_STR_LENGTH + 1 - off] = 0;
RTTESTI_CHECK_RC(RTUuidFromUtf16(&Uuid2, pwsz3), VERR_INVALID_UUID_FORMAT);
}
RTTestGuardedFree(hTest, pwsz2);
}
RTUtf16Free(pwsz);
}
RTTestSub(hTest, "RTUuidCompareStr");
RTTEST_CHECK(hTest, RTUuidCompareStr(&Uuid, sz) == 0);
RTTEST_CHECK(hTest, RTUuidCompareStr(&Uuid, "00000000-0000-0000-0000-000000000000") > 0);
RTTEST_CHECK(hTest, RTUuidCompareStr(&UuidNull, "00000000-0000-0000-0000-000000000000") == 0);
RTTestSub(hTest, "RTUuidCompare2Strs");
RTTEST_CHECK(hTest, RTUuidCompare2Strs(sz, sz) == 0);
RTTEST_CHECK(hTest, RTUuidCompare2Strs(sz, "00000000-0000-0000-0000-000000000000") > 0);
RTTEST_CHECK(hTest, RTUuidCompare2Strs("00000000-0000-0000-0000-000000000000", sz) < 0);
RTTEST_CHECK(hTest, RTUuidCompare2Strs("00000000-0000-0000-0000-000000000000", "00000000-0000-0000-0000-000000000000") == 0);
RTTEST_CHECK(hTest, RTUuidCompare2Strs("d95d883b-f91d-4ce5-a5c5-d08bb6a85dec", "a56193c7-3e0b-4c03-9d66-56efb45082f7") > 0);
RTTEST_CHECK(hTest, RTUuidCompare2Strs("a56193c7-3e0b-4c03-9d66-56efb45082f7", "d95d883b-f91d-4ce5-a5c5-d08bb6a85dec") < 0);
/*
* Check the binary representation.
*/
RTTestSub(hTest, "Binary representation");
RTUUID Uuid3;
Uuid3.au8[0] = 0x01;
Uuid3.au8[1] = 0x23;
Uuid3.au8[2] = 0x45;
Uuid3.au8[3] = 0x67;
Uuid3.au8[4] = 0x89;
Uuid3.au8[5] = 0xab;
Uuid3.au8[6] = 0xcd;
Uuid3.au8[7] = 0x4f;
Uuid3.au8[8] = 0x10;
Uuid3.au8[9] = 0xb2;
Uuid3.au8[10] = 0x54;
Uuid3.au8[11] = 0x76;
Uuid3.au8[12] = 0x98;
Uuid3.au8[13] = 0xba;
Uuid3.au8[14] = 0xdc;
Uuid3.au8[15] = 0xfe;
Uuid3.Gen.u8ClockSeqHiAndReserved = (Uuid3.Gen.u8ClockSeqHiAndReserved & 0x3f) | 0x80;
Uuid3.Gen.u16TimeHiAndVersion = (Uuid3.Gen.u16TimeHiAndVersion & 0x0fff) | 0x4000;
const char *pszUuid3 = "67452301-ab89-4fcd-90b2-547698badcfe";
rc = RTUuidToStr(&Uuid3, sz, sizeof(sz)); CHECK_RC();
RTTEST_CHECK(hTest, strcmp(sz, pszUuid3) == 0);
rc = RTUuidFromStr(&Uuid, pszUuid3); CHECK_RC();
RTTEST_CHECK(hTest, RTUuidCompare(&Uuid, &Uuid3) == 0);
RTTEST_CHECK(hTest, memcmp(&Uuid3, &Uuid, sizeof(Uuid)) == 0);
/*
* checking the clock seq and time hi and version bits...
*/
RTTestSub(hTest, "Clock seq, time hi, version bits");
RTUUID Uuid4Changes;
Uuid4Changes.au64[0] = 0;
Uuid4Changes.au64[1] = 0;
RTUUID Uuid4Prev;
RTUuidCreate(&Uuid4Prev);
for (unsigned i = 0; i < 1024; i++)
{
RTUUID Uuid4;
RTUuidCreate(&Uuid4);
Uuid4Changes.au64[0] |= Uuid4.au64[0] ^ Uuid4Prev.au64[0];
Uuid4Changes.au64[1] |= Uuid4.au64[1] ^ Uuid4Prev.au64[1];
#if 0 /** @todo make a bit string/dumper similar to %Rhxs/d. */
RTPrintf("tstUuid: %d %d %d %d-%d %d %d %d %d %d %d %d-%d %d %d %d ; %d %d %d %d-%d %d %d %d %d %d %d %d-%d %d %d %d\n",
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(0)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(1)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(2)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(3)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(4)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(5)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(6)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(7)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(8)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(9)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(10)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(11)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(12)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(13)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(14)),
!!(Uuid4.Gen.u16ClockSeq & RT_BIT(15)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(0)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(1)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(2)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(3)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(4)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(5)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(6)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(7)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(8)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(9)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(10)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(11)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(12)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(13)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(14)),
!!(Uuid4.Gen.u16TimeHiAndVersion & RT_BIT(15))
);
#endif
Uuid4Prev = Uuid4;
}
RTUUID Uuid4Fixed;
Uuid4Fixed.au64[0] = ~Uuid4Changes.au64[0];
Uuid4Fixed.au64[1] = ~Uuid4Changes.au64[1];
RTTestPrintf(hTest, RTTESTLVL_INFO, "fixed bits: %RTuuid (mask)\n", &Uuid4Fixed);
RTTestPrintf(hTest, RTTESTLVL_INFO, "tstUuid: raw: %.*Rhxs\n", sizeof(Uuid4Fixed), &Uuid4Fixed);
Uuid4Prev.au64[0] &= Uuid4Fixed.au64[0];
Uuid4Prev.au64[1] &= Uuid4Fixed.au64[1];
RTTestPrintf(hTest, RTTESTLVL_INFO, "tstUuid: fixed bits: %RTuuid (value)\n", &Uuid4Prev);
RTTestPrintf(hTest, RTTESTLVL_INFO, "tstUuid: raw: %.*Rhxs\n", sizeof(Uuid4Prev), &Uuid4Prev);
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
/**
* Completes the output, making sure that we're in
* the 1 position of a new line.
*/
static void tstCompleteOutput(void)
{
if (!g_fPendingPrefix)
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "\n");
g_fPendingPrefix = true;
}
int main(int argc, char **argv)
{
/*
* Initialize IPRT and create the test.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTS3", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* If no args, display usage.
*/
if (argc <= 2)
{
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Syntax: %s [Access Key] [Secret Key]\n", argv[0]);
return RTTestSkipAndDestroy(hTest, "Missing required arguments\n");
}
RTTestSubF(hTest, "Create S3");
RTS3 hS3;
rc = RTS3Create(&hS3, argv[1], argv[2], "object.storage.network.com", "tstS3-agent/1.0");
if (RT_FAILURE(rc))
{
RTTestIFailed("RTS3Create -> %Rrc", rc);
return RTTestSummaryAndDestroy(hTest);
}
RTTestSub(hTest, "Fetch buckets");
fetchAllBuckets(hS3);
RTTestSub(hTest, "Fetch keys");
fetchAllKeys(hS3, "bla");
#ifdef TSTS3_CREATEBUCKET
RTTestSub(hTest, "Create bucket");
createBucket(hS3, TSTS3_CREATEBUCKET_BUCKETNAME);
fetchAllBuckets(hS3);
deleteBucket(hS3, TSTS3_CREATEBUCKET_BUCKETNAME);
fetchAllBuckets(hS3);
#endif /* TSTS3_CREATEBUCKET */
#ifdef TSTS3_PUTGETKEY
RTTestSub(hTest, "Put key");
createBucket(hS3, TSTS3_PUTGETKEY_BUCKETNAME);
putKey(hS3, TSTS3_PUTGETKEY_BUCKETNAME, TSTS3_PUTGETKEY_KEYNAME, TSTS3_PUTGETKEY_PUTFILE);
fetchAllKeys(hS3, TSTS3_PUTGETKEY_BUCKETNAME);
getKey(hS3, TSTS3_PUTGETKEY_BUCKETNAME, TSTS3_PUTGETKEY_KEYNAME, TSTS3_PUTGETKEY_GETFILE);
deleteKey(hS3, TSTS3_PUTGETKEY_BUCKETNAME, TSTS3_PUTGETKEY_KEYNAME);
fetchAllKeys(hS3, TSTS3_PUTGETKEY_BUCKETNAME);
deleteBucket(hS3, TSTS3_PUTGETKEY_BUCKETNAME);
#endif /* TSTS3_PUTGETKEY */
RTS3Destroy(hS3);
/*
* Summary
*/
return RTTestSummaryAndDestroy(hTest);
}
static int testSessionConnection(RTTEST hTest, const char *pszExecPath)
{
RTTestSub(hTest, "testSessionConnection");
RTLOCALIPCSERVER ipcServer;
int rc = RTLocalIpcServerCreate(&ipcServer, "tstRTLocalIpcSessionConnection",
RTLOCALIPC_FLAGS_MULTI_SESSION);
if (RT_SUCCESS(rc))
{
#ifndef VBOX_TESTCASES_WITH_NO_THREADING
LOCALIPCTHREADCTX threadCtx = { ipcServer, hTest };
/* Spawn a simple worker thread and let it listen for incoming connections.
* In the meanwhile we try to cancel the server and see what happens. */
RTTHREAD hThread;
rc = RTThreadCreate(&hThread, testSessionConnectionThread,
&threadCtx, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc2");
if (RT_SUCCESS(rc))
{
do
{
RTPROCESS hProc;
const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionConnectionFork", NULL };
RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs,
RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
RTPROCSTATUS stsChild;
RTTEST_CHECK_RC_BREAK(hTest, RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &stsChild), VINF_SUCCESS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "Child terminated, waiting for server thread ...\n");
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS);
int threadRc;
RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
30 * 1000 /* 30s timeout */, &threadRc), VINF_SUCCESS);
RTTEST_CHECK_RC_BREAK(hTest, threadRc, VERR_CANCELLED);
RTTestPrintf(hTest, RTTESTLVL_INFO, "Server thread terminated successfully\n");
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
RTTEST_CHECK_BREAK(hTest, stsChild.enmReason == RTPROCEXITREASON_NORMAL);
RTTEST_CHECK_BREAK(hTest, stsChild.iStatus == 0);
}
while (0);
}
else
RTTestFailed(hTest, "Unable to create thread for cancelling server, rc=%Rrc\n", rc);
#else
do
{
RTPROCESS hProc;
const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionConnectionFork", NULL };
RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs,
RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
RTLOCALIPCSESSION ipcSession;
rc = RTLocalIpcServerListen(ipcServer, &ipcSession);
if (RT_SUCCESS(rc))
{
RTTestPrintf(hTest, RTTESTLVL_INFO, "testSessionConnectionThread: Got new client connection\n");
}
else
RTTestFailed(hTest, "Error while listening, rc=%Rrc\n", rc);
} while (0);
#endif
}
else
RTTestFailed(hTest, "Unable to create IPC server, rc=%Rrc\n", rc);
return VINF_SUCCESS;
}
static int testSessionData(RTTEST hTest, const char *pszExecPath)
{
RTTestSub(hTest, "testSessionData");
RTLOCALIPCSERVER ipcServer;
int rc = RTLocalIpcServerCreate(&ipcServer, "tstRTLocalIpcSessionData",
RTLOCALIPC_FLAGS_MULTI_SESSION);
if (RT_SUCCESS(rc))
{
LOCALIPCTHREADCTX threadCtx = { ipcServer, hTest };
#if 0
/* Run server + client in threads instead of fork'ed processes (useful for debugging). */
RTTHREAD hThreadServer, hThreadClient;
rc = RTThreadCreate(&hThreadServer, testSessionDataThread,
&threadCtx, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc4");
if (RT_SUCCESS(rc))
rc = RTThreadCreate(&hThreadClient, testSessionDataChildAsThread,
&hTest, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc5");
if (RT_SUCCESS(rc))
{
do
{
int threadRc;
RTTEST_CHECK_RC(hTest, RTThreadWait(hThreadServer,
5 * 60 * 1000 /* 5 minutes timeout */, &threadRc), VINF_SUCCESS);
RTTEST_CHECK_RC_BREAK(hTest, threadRc, VINF_SUCCESS);
RTTEST_CHECK_RC(hTest, RTThreadWait(hThreadClient,
5 * 60 * 1000 /* 5 minutes timeout */, &threadRc), VINF_SUCCESS);
RTTEST_CHECK_RC_BREAK(hTest, threadRc, VINF_SUCCESS);
} while (0);
}
#else
/* Spawn a simple worker thread and let it listen for incoming connections.
* In the meanwhile we try to cancel the server and see what happens. */
RTTHREAD hThread;
rc = RTThreadCreate(&hThread, testSessionDataThread,
&threadCtx, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc4");
if (RT_SUCCESS(rc))
{
do
{
RTPROCESS hProc;
const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionDataFork", NULL };
RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs,
RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS);
/* Wait for the server thread to terminate. */
int threadRc;
RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
5 * 60 * 1000 /* 5 minutes timeout */, &threadRc), VINF_SUCCESS);
RTTEST_CHECK_RC_BREAK(hTest, threadRc, VINF_SUCCESS);
RTTEST_CHECK_RC(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "Server thread terminated successfully\n");
/* Check if the child ran successfully. */
RTPROCSTATUS stsChild;
RTTEST_CHECK_RC_BREAK(hTest, RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &stsChild), VINF_SUCCESS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "Child terminated\n");
RTTEST_CHECK_BREAK(hTest, stsChild.enmReason == RTPROCEXITREASON_NORMAL);
RTTEST_CHECK_BREAK(hTest, stsChild.iStatus == 0);
}
while (0);
}
else
RTTestFailed(hTest, "Unable to create thread for cancelling server, rc=%Rrc\n", rc);
#endif
}
else
RTTestFailed(hTest, "Unable to create IPC server, rc=%Rrc\n", rc);
return !RTTestErrorCount(hTest) ? VINF_SUCCESS : VERR_GENERAL_FAILURE /* Doesn't matter */;
}