int main()
{
/*
* Init.
*/
RTTEST hTest;
int rc;
if ( RT_FAILURE(rc = RTR3InitExeNoArguments(0))
|| RT_FAILURE(rc = RTTestCreate("tstVMMR0CallHost-1", &hTest)))
{
RTStrmPrintf(g_pStdErr, "tstVMMR0CallHost-1: Fatal error during init: %Rrc\n", rc);
return 1;
}
RTTestBanner(hTest);
g_Jmp.pvSavedStack = (RTR0PTR)RTTestGuardedAllocTail(hTest, VMM_STACK_SIZE);
/*
* Run two test with about 1000 long jumps each.
*/
RTTestSub(hTest, "Increasing stack usage");
tst(0, 7000, 1);
RTTestSub(hTest, "Decreasing stack usage");
tst(7599, 0, -1);
return RTTestSummaryAndDestroy(hTest);
}
static RTEXITCODE tstRTPipe4Child(const char *pszPipe)
{
int rc = RTR3InitExeNoArguments(0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
int64_t iNative;
rc = RTStrToInt64Full(pszPipe, 10, &iNative);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTStrToUInt64Full(%s) -> %Rrc\n", pszPipe, rc);
RTPIPE hPipe;
rc = RTPipeFromNative(&hPipe, (RTHCINTPTR)iNative, RTPIPE_N_WRITE);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeFromNative(,%s,WRITE) -> %Rrc\n", pszPipe, rc);
rc = RTPipeWriteBlocking(hPipe, g_szTest4Message, sizeof(g_szTest4Message) - 1, NULL);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeWriteBlocking() -> %Rrc\n", rc);
rc = RTPipeClose(hPipe);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeClose() -> %Rrc\n", rc);
return RTEXITCODE_SUCCESS;
}
void UINetworkReplyPrivateThread::run()
{
/* Init: */
RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
/* Create HTTP object: */
if (RT_SUCCESS(m_iError))
m_iError = RTHttpCreate(&m_pHttp);
/* Apply proxy-rules: */
if (RT_SUCCESS(m_iError))
m_iError = applyProxyRules();
/* Apply https-certificates: */
if (RT_SUCCESS(m_iError))
m_iError = applyHttpsCertificates();
/* Assign raw-headers: */
if (RT_SUCCESS(m_iError))
m_iError = applyRawHeaders();
/* Perform main request: */
if (RT_SUCCESS(m_iError))
m_iError = performMainRequest();
/* Destroy HTTP object: */
if (m_pHttp)
{
RTHttpDestroy(m_pHttp);
m_pHttp = 0;
}
}
int main()
{
int cErrors = 0;
RTR3InitExeNoArguments(0);
RTPrintf("tstErrUnique: TESTING\n");
for (uint32_t i = 0; i < RT_ELEMENTS(g_aErrorMessages) - 1; i++)
{
if (strIsPermissibleDuplicate(&g_aErrorMessages[i]))
continue;
for (uint32_t j = i + 1; j < RT_ELEMENTS(g_aErrorMessages); j++)
{
if (strIsPermissibleDuplicate(&g_aErrorMessages[j]))
continue;
if (g_aErrorMessages[i].iCode == g_aErrorMessages[j].iCode)
{
RTPrintf("tstErrUnique: status code %d can mean '%s' or '%s'\n", g_aErrorMessages[i].iCode, g_aErrorMessages[i].pszMsgShort, g_aErrorMessages[j]);
cErrors++;
}
}
}
/*
* Summary
*/
if (cErrors == 0)
RTPrintf("tstErrUnique: SUCCESS\n");
else
RTPrintf("tstErrUnique: FAILURE - %d errors\n", cErrors);
return !!cErrors;
}
static int tstRTCreateProcEx1Child(void)
{
int rc = RTR3InitExeNoArguments(0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
RTPrintf("it works");
RTStrmPrintf(g_pStdErr, "ignore this output\n");
return RTEXITCODE_SUCCESS;
}
int main()
{
unsigned cErrors = 0;
int i;
RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
RTPrintf("tstTime-2: TESTING...\n");
/*
* 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();
#define NUMBER_OF_CALLS (100*_1M)
for (i = 0; i < NUMBER_OF_CALLS; i++)
RTTimeNanoTS();
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))
{
RTPrintf("tstTime-2: error: total time differs too much! u64OSElapsedTS=%#llx u64RTElapsedTS=%#llx delta=%lld\n",
u64OSElapsedTS, u64RTElapsedTS, u64OSElapsedTS - u64RTElapsedTS);
cErrors++;
}
else
RTPrintf("tstTime-2: total time difference: u64OSElapsedTS=%#llx u64RTElapsedTS=%#llx delta=%lld\n",
u64OSElapsedTS, u64RTElapsedTS, u64OSElapsedTS - u64RTElapsedTS);
RTPrintf("tstTime-2: %u calls to RTTimeNanoTS\n", NUMBER_OF_CALLS);
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) /** @todo This isn't really x86 or AMD64 specific... */
RTPrintf("tstTime-2: RTTimeDbgSteps -> %u (%d ppt)\n", RTTimeDbgSteps(), ((uint64_t)RTTimeDbgSteps() * 1000) / NUMBER_OF_CALLS);
RTPrintf("tstTime-2: RTTimeDbgExpired -> %u (%d ppt)\n", RTTimeDbgExpired(), ((uint64_t)RTTimeDbgExpired() * 1000) / NUMBER_OF_CALLS);
RTPrintf("tstTime-2: RTTimeDbgBad -> %u (%d ppt)\n", RTTimeDbgBad(), ((uint64_t)RTTimeDbgBad() * 1000) / NUMBER_OF_CALLS);
RTPrintf("tstTime-2: RTTimeDbgRaces -> %u (%d ppt)\n", RTTimeDbgRaces(), ((uint64_t)RTTimeDbgRaces() * 1000) / NUMBER_OF_CALLS);
#endif
if (!cErrors)
RTPrintf("tstTime-2: SUCCESS\n");
else
RTPrintf("tstTime-2: FAILURE - %d errors\n", cErrors);
return !!cErrors;
}
static int tstRTCreateProcEx3Child(void)
{
int rc = RTR3InitExeNoArguments(0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
RTStrmPrintf(g_pStdOut, "w"); RTStrmFlush(g_pStdOut);
RTStrmPrintf(g_pStdErr, "o"); RTStrmFlush(g_pStdErr);
RTStrmPrintf(g_pStdOut, "r"); RTStrmFlush(g_pStdOut);
RTStrmPrintf(g_pStdErr, "k"); RTStrmFlush(g_pStdErr);
RTStrmPrintf(g_pStdOut, "s");
return RTEXITCODE_SUCCESS;
}
int main()
{
uint64_t u64TotalTS;
uint64_t u64MinTS;
uint64_t u64MaxTS;
unsigned i;
RTR3InitExeNoArguments(0);
RTPrintf("tstPrfRT: TESTING...\n");
/*
* RTTimeNanoTS, RTTimeProgramNanoTS, RTTimeMilliTS, and RTTimeProgramMilliTS.
*/
ITERATE(RT_NOTHING, RTTimeNanoTS();, RT_NOTHING, 1000000);
int main(int argc, char **argv)
{
RTR3InitExeNoArguments(0);
if (argc != 1)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "This utility takes no arguments\n");
NOREF(argv);
int rc = SUPR3Uninstall();
if (RT_SUCCESS(rc))
{
RTMsgInfo("uninstalled successfully");
return RTEXITCODE_SUCCESS;
}
return RTMsgErrorExit(RTEXITCODE_FAILURE, "uninstallation failed. rc=%Rrc", rc);
}
int main()
{
RTR3InitExeNoArguments(0);
printf("tstLog: Requires manual inspection of the log output!\n");
RTLogPrintf("%%Rrc %d: %Rrc\n", VERR_INVALID_PARAMETER, VERR_INVALID_PARAMETER);
RTLogPrintf("%%Rrs %d: %Rrs\n", VERR_INVALID_PARAMETER, VERR_INVALID_PARAMETER);
RTLogPrintf("%%Rrf %d: %Rrf\n", VERR_INVALID_PARAMETER, VERR_INVALID_PARAMETER);
RTLogPrintf("%%Rra %d: %Rra\n", VERR_INVALID_PARAMETER, VERR_INVALID_PARAMETER);
static uint8_t au8Hex[256];
for (unsigned iHex = 0; iHex < sizeof(au8Hex); iHex++)
au8Hex[iHex] = (uint8_t)iHex;
RTLogPrintf("%%Rhxs : %Rhxs\n", &au8Hex[0]);
RTLogPrintf("%%.32Rhxs: %.32Rhxs\n", &au8Hex[0]);
RTLogPrintf("%%Rhxd :\n%Rhxd\n", &au8Hex[0]);
RTLogPrintf("%%.64Rhxd:\n%.64Rhxd\n", &au8Hex[0]);
RTLogPrintf("%%.*Rhxd:\n%.*Rhxd\n", 64, &au8Hex[0]);
RTLogPrintf("%%32.256Rhxd : \n%32.256Rhxd\n", &au8Hex[0]);
RTLogPrintf("%%32.*Rhxd : \n%32.*Rhxd\n", 256, &au8Hex[0]);
RTLogPrintf("%%7.32Rhxd : \n%7.32Rhxd\n", &au8Hex[0]);
RTLogPrintf("%%7.*Rhxd : \n%7.*Rhxd\n", 32, &au8Hex[0]);
RTLogPrintf("%%*.*Rhxd : \n%*.*Rhxd\n", 7, 32, &au8Hex[0]);
RTLogPrintf("%%RGp: %RGp\n", (RTGCPHYS)0x87654321);
RTLogPrintf("%%RGv: %RGv\n", (RTGCPTR)0x87654321);
RTLogPrintf("%%RHp: %RHp\n", (RTGCPHYS)0x87654321);
RTLogPrintf("%%RHv: %RHv\n", (RTGCPTR)0x87654321);
RTLogPrintf("%%RI8 : %RI8\n", (uint8_t)808);
RTLogPrintf("%%RI16: %RI16\n", (uint16_t)16016);
RTLogPrintf("%%RI32: %RI32\n", _1G);
RTLogPrintf("%%RI64: %RI64\n", _1E);
RTLogPrintf("%%RU8 : %RU8\n", (uint8_t)808);
RTLogPrintf("%%RU16: %RU16\n", (uint16_t)16016);
RTLogPrintf("%%RU32: %RU32\n", _2G32);
RTLogPrintf("%%RU64: %RU64\n", _2E);
RTLogPrintf("%%RX8 : %RX8 %#RX8\n", (uint8_t)808, (uint8_t)808);
RTLogPrintf("%%RX16: %RX16 %#RX16\n", (uint16_t)16016, (uint16_t)16016);
RTLogPrintf("%%RX32: %RX32 %#RX32\n", _2G32, _2G32);
RTLogPrintf("%%RX64: %RX64 %#RX64\n", _2E, _2E);
RTLogFlush(NULL);
return 0;
}
/**
* Entry point.
*/
extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
{
/*
* Init runtime.
*/
RTTEST hTest;
RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
RTEXITCODE rcExit = RTTestInitAndCreate("tstCFGM", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
doInVmmTests(hTest);
doStandaloneTests();
return RTTestSummaryAndDestroy(hTest);
}
int main()
{
unsigned cErrors = 0;
RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
RTPrintf("tstTime-4: TESTING...\n");
/*
* Check that RTTimeSystemNanoTS doesn't go backwards and
* isn't too far from RTTimeNanoTS().
*/
RTTimeSystemNanoTS(); RTTimeNanoTS(); RTThreadYield(); /* warmup */
const uint64_t SysStartTS = RTTimeSystemNanoTS();
const uint64_t GipStartTS = RTTimeNanoTS();
uint64_t SysPrevTS, GipPrevTS;
do
{
SysPrevTS = RTTimeSystemNanoTS();
GipPrevTS = RTTimeNanoTS();
if (SysPrevTS < SysStartTS)
{
cErrors++;
RTPrintf("tstTime-4: Bad Sys time!\n");
}
if (GipPrevTS < GipStartTS)
{
cErrors++;
RTPrintf("tstTime-4: Bad Gip time!\n");
}
uint64_t Delta = GipPrevTS > SysPrevTS ? GipPrevTS - SysPrevTS :
SysPrevTS - GipPrevTS;
if (Delta > 100000000ULL /* 100 ms */ )
{
cErrors++;
RTPrintf("tstTime-4: Delta=%llu (GipPrevTS=%llu, SysPrevTS=%llu)!\n", Delta, GipPrevTS, SysPrevTS);
}
} while (SysPrevTS - SysStartTS < 2000000000 /* 2s */);
if (!cErrors)
RTPrintf("tstTime-4: SUCCESS\n");
else
RTPrintf("tstTime-4: FAILURE - %d errors\n", cErrors);
return !!cErrors;
}
static int tstRTCreateProcEx4Child(int argc, char **argv)
{
int rc = RTR3InitExeNoArguments(0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
int cErrors = 0;
for (int i = 0; i < argc; i++)
if (strcmp(argv[i], g_apszArgs4[i]))
{
RTStrmPrintf(g_pStdErr,
"child4: argv[%2u]='%s'\n"
"child4: expected='%s'\n",
i, argv[i], g_apszArgs4[i]);
cErrors++;
}
return cErrors == 0 ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
}
int main()
{
/*
* Init globals and such.
*/
RTR3InitExeNoArguments(0);
int rc = VbglR3Init();
if (RT_FAILURE(rc))
{
RTPrintf("VbglR3Init failed with rc=%Rrc.\n", rc);
return -1;
}
#ifdef RT_OS_WINDOWS
WCHAR wszPath[MAX_PATH];
HRESULT hRes = SHGetFolderPathW(0, CSIDL_APPDATA, 0, 0, wszPath);
if (SUCCEEDED(hRes))
{
RTPrintf("SHGetFolderPathW (CSIDL_APPDATA) = %ls\n", wszPath);
hRes = SHGetFolderPathW(0, CSIDL_PERSONAL, 0, 0, wszPath);
if (SUCCEEDED(hRes))
{
RTPrintf("SHGetFolderPathW (CSIDL_PERSONAL) = %ls\n", wszPath);
}
else
RTPrintf("SHGetFolderPathW (CSIDL_PERSONAL) returned error: 0x%x\n", hRes);
}
else
RTPrintf("SHGetFolderPathW (CSIDL_APPDATA) returned error: 0x%x\n", hRes);
if (FAILED(hRes))
rc = RTErrConvertFromWin32(hRes);
/* Dump env bits. */
RTPrintf("Environment:\n\n");
RTPrintf("APPDATA = %s\n", getenv("APPDATA"));
#endif
return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
}
static RTEXITCODE tstRTPipe5Child(const char *pszPipe)
{
int rc = RTR3InitExeNoArguments(0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
int64_t iNative;
rc = RTStrToInt64Full(pszPipe, 10, &iNative);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTStrToUInt64Full(%s) -> %Rrc\n", pszPipe, rc);
RTPIPE hPipe;
rc = RTPipeFromNative(&hPipe, (RTHCINTPTR)iNative, RTPIPE_N_READ);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeFromNative(,%s,READ) -> %Rrc\n", pszPipe, rc);
///
char szTmp[1024];
size_t cbRead = 0;
rc = RTPipeReadBlocking(hPipe, szTmp, sizeof(szTmp) - 1, &cbRead);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeReadBlocking() -> %Rrc\n", rc);
szTmp[cbRead] = '\0';
size_t cbRead2;
char szTmp2[4];
rc = RTPipeReadBlocking(hPipe, szTmp2, sizeof(szTmp2), &cbRead2);
if (rc != VERR_BROKEN_PIPE)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeReadBlocking() -> %Rrc instead of VERR_BROKEN_PIPE\n", rc);
rc = RTPipeClose(hPipe);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeClose() -> %Rrc\n", rc);
if (memcmp(szTmp, g_szTest5Message, sizeof(g_szTest5Message)))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Message mismatch.\n:Expected '%s'\nGot '%s'\n", g_szTest5Message, szTmp);
return RTEXITCODE_SUCCESS;
}
int main(int argc, char **argv)
{
RTR3InitExeNoArguments(0);
if (argc != 1)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "This utility takes no arguments");
NOREF(argv);
int rc = SUPR3Install();
if (RT_SUCCESS(rc))
{
if (rc == VINF_SUCCESS)
RTMsgInfo("Installed successfully!");
else if (rc == VINF_ALREADY_INITIALIZED)
RTMsgInfo("Already loaded.");
else if (rc == VWRN_ALREADY_EXISTS)
RTMsgInfo("Service already existed; started successfully.");
else
RTMsgInfo("Unexpected status: %Rrc", rc);
return RTEXITCODE_SUCCESS;
}
return RTMsgErrorExit(RTEXITCODE_FAILURE, "installation failed. rc=%Rrc", rc);
}
int main()
{
RTR3InitExeNoArguments(0);
RTPrintf("tstRTMemEf: TESTING...\n");
#define CHECK_EXPR(expr) \
do { bool const f = !!(expr); if (!f) { RTPrintf("tstRTMemEf(%d): %s!\n", __LINE__, #expr); g_cErrors++; } } while (0)
/*
* Some simple stuff.
*/
{
CHECK_EXPR(tstMemAllocEfAccess());
}
/*
* Summary.
*/
if (!g_cErrors)
RTPrintf("tstMemAutoPtr: SUCCESS\n");
else
RTPrintf("tstMemAutoPtr: FAILED - %d errors\n", g_cErrors);
return !!g_cErrors;
}
static int tstRTCreateProcEx5Child(int argc, char **argv)
{
int rc = RTR3InitExeNoArguments(0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
#ifdef RT_OS_WINDOWS
char szUser[_1K];
DWORD cbLen = sizeof(szUser);
/** @todo Does not yet handle ERROR_MORE_DATA for user names longer than 32767. */
if (!GetUserName(szUser, &cbLen))
{
RTPrintf("GetUserName failed with last error=%ld\n", GetLastError());
return RTEXITCODE_FAILURE;
}
# if 0 /* Does not work on NT4 (yet). */
DWORD cbSid = 0;
DWORD cbDomain = 0;
SID_NAME_USE sidUse;
/* First try to figure out how much space for SID + domain name we need. */
BOOL bRet = LookupAccountName(NULL /* current system*/,
szUser,
NULL,
&cbSid,
NULL,
&cbDomain,
&sidUse);
if (!bRet)
{
DWORD dwErr = GetLastError();
if (dwErr != ERROR_INSUFFICIENT_BUFFER)
{
RTPrintf("LookupAccountName(1) failed with last error=%ld\n", dwErr);
return RTEXITCODE_FAILURE;
}
}
/* Now try getting the real SID + domain name. */
SID *pSid = (SID *)RTMemAlloc(cbSid);
AssertPtr(pSid);
char *pszDomain = (char *)RTMemAlloc(cbDomain); /* Size in TCHAR! */
AssertPtr(pszDomain);
if (!LookupAccountName(NULL /* Current system */,
szUser,
pSid,
&cbSid,
pszDomain,
&cbDomain,
&sidUse))
{
RTPrintf("LookupAccountName(2) failed with last error=%ld\n", GetLastError());
return RTEXITCODE_FAILURE;
}
RTMemFree(pSid);
RTMemFree(pszDomain);
# endif
#else
/** @todo Lookup UID/effective UID, maybe GID? */
#endif
return RTEXITCODE_SUCCESS;
}
/**
* Main function
*/
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
/* Do not use a global namespace ("Global\\") for mutex name here, will blow up NT4 compatibility! */
HANDLE hMutexAppRunning = CreateMutex(NULL, FALSE, "VBoxTray");
if ( hMutexAppRunning != NULL
&& GetLastError() == ERROR_ALREADY_EXISTS)
{
/* Close the mutex for this application instance. */
CloseHandle (hMutexAppRunning);
hMutexAppRunning = NULL;
return 0;
}
LogRel(("VBoxTray: %s r%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr()));
int rc = RTR3InitExeNoArguments(0);
if (RT_SUCCESS(rc))
{
rc = VbglR3Init();
if (RT_SUCCESS(rc))
rc = vboxTrayOpenBaseDriver();
}
if (RT_SUCCESS(rc))
{
/* Save instance handle. */
ghInstance = hInstance;
hlpReportStatus(VBoxGuestFacilityStatus_Init);
rc = vboxTrayCreateToolWindow();
if (RT_SUCCESS(rc))
{
rc = vboxTraySetupSeamless();
if (RT_SUCCESS(rc))
{
Log(("VBoxTray: Init successful\n"));
rc = vboxTrayServiceMain();
if (RT_SUCCESS(rc))
hlpReportStatus(VBoxGuestFacilityStatus_Terminating);
vboxTrayShutdownSeamless();
}
vboxTrayDestroyToolWindow();
}
if (RT_SUCCESS(rc))
hlpReportStatus(VBoxGuestFacilityStatus_Terminated);
}
if (RT_FAILURE(rc))
{
LogRel(("VBoxTray: Error while starting, rc=%Rrc\n", rc));
hlpReportStatus(VBoxGuestFacilityStatus_Failed);
}
LogRel(("VBoxTray: Ended\n"));
vboxTrayCloseBaseDriver();
/* Release instance mutex. */
if (hMutexAppRunning != NULL)
{
CloseHandle(hMutexAppRunning);
hMutexAppRunning = NULL;
}
VbglR3Term();
return RT_SUCCESS(rc) ? 0 : 1;
}
int main()
{
RTR3InitExeNoArguments(0);
RTPrintf("tstMemAutoPtr: TESTING...\n");
#define CHECK_EXPR(expr) \
do { bool const f = !!(expr); if (!f) { RTPrintf("tstMemAutoPtr(%d): %s!\n", __LINE__, #expr); g_cErrors++; } } while (0)
/*
* Some simple stuff.
*/
{
RTCMemAutoPtr<char> NilObj;
CHECK_EXPR(!NilObj);
CHECK_EXPR(NilObj.get() == NULL);
CHECK_EXPR(NilObj.release() == NULL);
NilObj.reset();
}
{
RTCMemAutoPtr<char> Alloc(10);
CHECK_EXPR(Alloc.get() != NULL);
char *pch = Alloc.release();
CHECK_EXPR(pch != NULL);
CHECK_EXPR(Alloc.get() == NULL);
RTCMemAutoPtr<char> Manage(pch);
CHECK_EXPR(Manage.get() == pch);
CHECK_EXPR(&Manage[0] == pch);
CHECK_EXPR(&Manage[1] == &pch[1]);
CHECK_EXPR(&Manage[9] == &pch[9]);
}
/*
* Use the electric fence memory API to check alternative template
* arguments and also check some subscript / reference limit thing.
*/
{
RTCMemAutoPtr<char, RTCMemEfAutoFree<char>, RTMemEfReallocNP> Electric(10);
CHECK_EXPR(Electric.get() != NULL);
Electric[0] = '0';
CHECK_EXPR(Electric[0] == '0');
CHECK_EXPR(*Electric == '0');
//CHECK_EXPR(Electric == '0');
Electric[9] = '1';
CHECK_EXPR(Electric[9] == '1');
/* Electric[10] = '2'; - this will crash (of course) */
}
/*
* Check that memory is actually free when it should be and isn't when it shouldn't.
* Use the electric heap to get some extra checks.
*/
g_cFrees = 0;
{
RTCMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfReallocNP> FreeIt(128);
FreeIt[127] = '0';
}
CHECK_EXPR(g_cFrees == 1);
g_cFrees = 0;
{
RTCMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfReallocNP> FreeIt2(128);
FreeIt2[127] = '1';
FreeIt2.reset();
FreeIt2.alloc(128);
FreeIt2[127] = '2';
FreeIt2.reset(FreeIt2.get()); /* this one is weird, but it's how things works... */
}
CHECK_EXPR(g_cFrees == 2);
g_cFrees = 0;
{
RTCMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfReallocNP> DontFreeIt(256);
DontFreeIt[255] = '0';
RTMemEfFreeNP(DontFreeIt.release());
}
CHECK_EXPR(g_cFrees == 0);
g_cFrees = 0;
{
RTCMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfReallocNP> FreeIt3(128);
FreeIt3[127] = '0';
CHECK_EXPR(FreeIt3.realloc(128));
FreeIt3[127] = '0';
CHECK_EXPR(FreeIt3.realloc(256));
FreeIt3[255] = '0';
CHECK_EXPR(FreeIt3.realloc(64));
FreeIt3[63] = '0';
CHECK_EXPR(FreeIt3.realloc(32));
FreeIt3[31] = '0';
}
CHECK_EXPR(g_cFrees == 1);
g_cFrees = 0;
{
RTCMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfReallocNP> FreeIt4;
CHECK_EXPR(FreeIt4.alloc(123));
CHECK_EXPR(FreeIt4.realloc(543));
FreeIt4 = (char *)NULL;
CHECK_EXPR(FreeIt4.get() == NULL);
}
CHECK_EXPR(g_cFrees == 1);
/*
* Check the ->, [] and * (unary) operators with some useful struct.
*/
{
RTCMemAutoPtr<TSTMEMAUTOPTRSTRUCT> Struct1(1);
Struct1->a = 0x11223344;
Struct1->b = 0x55667788;
Struct1->c = 0x99aabbcc;
CHECK_EXPR(Struct1->a == 0x11223344);
CHECK_EXPR(Struct1->b == 0x55667788);
CHECK_EXPR(Struct1->c == 0x99aabbcc);
Struct1[0].a = 0x11223344;
Struct1[0].b = 0x55667788;
Struct1[0].c = 0x99aabbcc;
CHECK_EXPR(Struct1[0].a == 0x11223344);
CHECK_EXPR(Struct1[0].b == 0x55667788);
CHECK_EXPR(Struct1[0].c == 0x99aabbcc);
(*Struct1).a = 0x11223344;
(*Struct1).b = 0x55667788;
(*Struct1).c = 0x99aabbcc;
CHECK_EXPR((*Struct1).a == 0x11223344);
CHECK_EXPR((*Struct1).b == 0x55667788);
CHECK_EXPR((*Struct1).c == 0x99aabbcc);
/* since at it... */
Struct1.get()->a = 0x11223344;
Struct1.get()->b = 0x55667788;
Struct1.get()->c = 0x99aabbcc;
CHECK_EXPR(Struct1.get()->a == 0x11223344);
CHECK_EXPR(Struct1.get()->b == 0x55667788);
CHECK_EXPR(Struct1.get()->c == 0x99aabbcc);
}
/*
* Check the zeroing of memory.
*/
{
RTCMemAutoPtr<uint64_t, RTCMemAutoDestructor<uint64_t>, tstMemAutoPtrAllocatorNoZero> Zeroed1(1, true);
CHECK_EXPR(*Zeroed1 == 0);
}
{
RTCMemAutoPtr<uint64_t, RTCMemAutoDestructor<uint64_t>, tstMemAutoPtrAllocatorNoZero> Zeroed2;
Zeroed2.alloc(5, true);
CHECK_EXPR(Zeroed2[0] == 0);
CHECK_EXPR(Zeroed2[1] == 0);
CHECK_EXPR(Zeroed2[2] == 0);
CHECK_EXPR(Zeroed2[3] == 0);
CHECK_EXPR(Zeroed2[4] == 0);
}
/*
* Summary.
*/
if (!g_cErrors)
RTPrintf("tstMemAutoPtr: SUCCESS\n");
else
RTPrintf("tstMemAutoPtr: FAILED - %d errors\n", g_cErrors);
return !!g_cErrors;
}
int main()
{
/*
* Prologue.
*/
RTR3InitExeNoArguments(0);
RTPrintf("tstNoCrt-1: TESTING...\n");
/*
* Sanity.
*/
TSTBUF Buf1;
TstBufInit(&Buf1, 1);
my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, "sanity buf1");
TstBufCheck(&Buf1, "sanity buf1");
TSTBUF Buf2;
TstBufInit(&Buf2, 2);
my_memcheck(Buf2.abBuf, 2, TSTBUF_SIZE, "sanity buf2");
TstBufCheck(&Buf2, "sanity buf2");
if (g_cErrors)
{
RTPrintf("tstNoCrt-1: FAILED - fatal sanity error\n");
return 1;
}
#define CHECK_CCH(expect) \
do \
{ \
if (cch != (expect)) \
{ \
RTPrintf("tstNoCrt-1(%d): cb=%zu expected=%zu\n", __LINE__, cch, (expect)); \
g_cErrors++; \
} \
} while (0)
size_t cch;
#define CHECK_PV(expect) \
do \
{ \
if (pv != (expect)) \
{ \
RTPrintf("tstNoCrt-1(%d): pv=%p expected=%p\n", __LINE__, pv, (expect)); \
g_cErrors++; \
} \
} while (0)
void *pv;
#define CHECK_DIFF(op) \
do \
{ \
if (!(iDiff op 0)) \
{ \
RTPrintf("tstNoCrt-1(%d): iDiff=%d expected: %s 0\n", __LINE__, iDiff, #op); \
g_cErrors++; \
} \
} while (0)
int iDiff;
static char s_szTest1[] = "0123456789abcdef";
static char s_szTest2[] = "0123456789abcdef";
static char s_szTest3[] = "fedcba9876543210";
/*
* memcpy.
*/
RTPrintf("tstNoCrt-1: memcpy\n");
TstBufInit(&Buf1, 1);
TstBufInit(&Buf2, 2);
pv = RT_NOCRT(memcpy)(Buf1.abBuf, Buf2.abBuf, TSTBUF_SIZE); CHECK_PV(Buf1.abBuf);
my_memcheck(Buf1.abBuf, 2, TSTBUF_SIZE, "memcpy1-dst");
my_memcheck(Buf2.abBuf, 2, TSTBUF_SIZE, "memcpy1-src");
TstBufCheck(&Buf1, "memcpy1");
TstBufCheck(&Buf2, "memcpy1");
TstBufInit(&Buf1, 3);
TstBufInit(&Buf2, 4);
pv = RT_NOCRT(memcpy)(Buf2.abBuf, Buf1.abBuf, TSTBUF_SIZE); CHECK_PV(Buf2.abBuf);
my_memcheck(Buf1.abBuf, 3, TSTBUF_SIZE, "memcpy2-dst");
my_memcheck(Buf2.abBuf, 3, TSTBUF_SIZE, "memcpy2-src");
TstBufCheck(&Buf1, "memcpy2");
TstBufCheck(&Buf2, "memcpy2");
TstBufInit(&Buf1, 5);
TstBufInit(&Buf2, 6);
pv = RT_NOCRT(memcpy)(Buf2.abBuf, Buf1.abBuf, 0); CHECK_PV(Buf2.abBuf);
my_memcheck(Buf1.abBuf, 5, TSTBUF_SIZE, "memcpy3-dst");
my_memcheck(Buf2.abBuf, 6, TSTBUF_SIZE, "memcpy3-src");
TstBufCheck(&Buf1, "memcpy3-dst");
TstBufCheck(&Buf2, "memcpy3-src");
for (unsigned off1 = 0; off1 <= 128; off1++)
{
for (unsigned off2 = 0; off2 <= 256; off2++)
{
char sz[32];
RTStrPrintf(sz, sizeof(sz), "memcpy4-%d-%d", off1, off2);
TstBufInit(&Buf1, 1);
TstBufInit(&Buf2, 2);
size_t cb = off2;
pv = RT_NOCRT(memcpy)(&Buf2.abBuf[off2], &Buf1.abBuf[off1], cb); CHECK_PV(&Buf2.abBuf[off2]);
my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, sz);
my_memcheck(Buf2.abBuf, 2, off2, sz);
my_memcheck(&Buf2.abBuf[off2], 1, cb, sz);
my_memcheck(&Buf2.abBuf[off2 + cb], 2, TSTBUF_SIZE - cb - off2, sz);
TstBufCheck(&Buf1, sz);
TstBufCheck(&Buf2, sz);
}
}
/*
* mempcpy.
*/
RTPrintf("tstNoCrt-1: mempcpy\n");
TstBufInit(&Buf1, 1);
TstBufInit(&Buf2, 2);
pv = RT_NOCRT(mempcpy)(Buf1.abBuf, Buf2.abBuf, TSTBUF_SIZE); CHECK_PV(&Buf1.abBuf[TSTBUF_SIZE]);
my_memcheck(Buf1.abBuf, 2, TSTBUF_SIZE, "mempcpy1-dst");
my_memcheck(Buf2.abBuf, 2, TSTBUF_SIZE, "mempcpy1-src");
TstBufCheck(&Buf1, "mempcpy1");
TstBufCheck(&Buf2, "mempcpy1");
TstBufInit(&Buf1, 3);
TstBufInit(&Buf2, 4);
pv = RT_NOCRT(mempcpy)(Buf2.abBuf, Buf1.abBuf, TSTBUF_SIZE); CHECK_PV(&Buf2.abBuf[TSTBUF_SIZE]);
my_memcheck(Buf1.abBuf, 3, TSTBUF_SIZE, "mempcpy2-dst");
my_memcheck(Buf2.abBuf, 3, TSTBUF_SIZE, "mempcpy2-src");
TstBufCheck(&Buf1, "mempcpy2");
TstBufCheck(&Buf2, "mempcpy2");
TstBufInit(&Buf1, 5);
TstBufInit(&Buf2, 6);
pv = RT_NOCRT(mempcpy)(Buf2.abBuf, Buf1.abBuf, 0); CHECK_PV(Buf2.abBuf);
my_memcheck(Buf1.abBuf, 5, TSTBUF_SIZE, "mempcpy3-dst");
my_memcheck(Buf2.abBuf, 6, TSTBUF_SIZE, "mempcpy3-src");
TstBufCheck(&Buf1, "mempcpy3-dst");
TstBufCheck(&Buf2, "mempcpy3-src");
for (unsigned off1 = 0; off1 <= 128; off1++)
{
for (unsigned off2 = 0; off2 <= 256; off2++)
{
char sz[32];
RTStrPrintf(sz, sizeof(sz), "mempcpy4-%d-%d", off1, off2);
TstBufInit(&Buf1, 1);
TstBufInit(&Buf2, 2);
size_t cb = off2;
pv = RT_NOCRT(mempcpy)(&Buf2.abBuf[off2], &Buf1.abBuf[off1], cb); CHECK_PV(&Buf2.abBuf[off2 + cb]);
my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, sz);
my_memcheck(Buf2.abBuf, 2, off2, sz);
my_memcheck(&Buf2.abBuf[off2], 1, cb, sz);
my_memcheck(&Buf2.abBuf[off2 + cb], 2, TSTBUF_SIZE - cb - off2, sz);
TstBufCheck(&Buf1, sz);
TstBufCheck(&Buf2, sz);
}
}
/*
* memmove.
*/
RTPrintf("tstNoCrt-1: memmove\n");
TstBufInit(&Buf1, 1);
TstBufInit(&Buf2, 2);
pv = RT_NOCRT(memmove)(Buf1.abBuf, Buf2.abBuf, TSTBUF_SIZE); CHECK_PV(Buf1.abBuf);
my_memcheck(Buf1.abBuf, 2, TSTBUF_SIZE, "memmove1-dst");
my_memcheck(Buf2.abBuf, 2, TSTBUF_SIZE, "memmove1-src");
TstBufCheck(&Buf1, "memmove1");
TstBufCheck(&Buf2, "memmove1");
TstBufInit(&Buf1, 3);
TstBufInit(&Buf2, 4);
pv = RT_NOCRT(memmove)(Buf2.abBuf, Buf1.abBuf, TSTBUF_SIZE); CHECK_PV(Buf2.abBuf);
my_memcheck(Buf1.abBuf, 3, TSTBUF_SIZE, "memmove2-dst");
my_memcheck(Buf2.abBuf, 3, TSTBUF_SIZE, "memmove2-src");
TstBufCheck(&Buf1, "memmove2");
TstBufCheck(&Buf2, "memmove2");
TstBufInit(&Buf1, 5);
TstBufInit(&Buf2, 6);
pv = RT_NOCRT(memmove)(Buf2.abBuf, Buf1.abBuf, 0); CHECK_PV(Buf2.abBuf);
my_memcheck(Buf1.abBuf, 5, TSTBUF_SIZE, "memmove3-dst");
my_memcheck(Buf2.abBuf, 6, TSTBUF_SIZE, "memmove3-src");
TstBufCheck(&Buf1, "memmove3-dst");
TstBufCheck(&Buf2, "memmove3-src");
for (unsigned off1 = 1; off1 <= 128; off1++)
{
for (unsigned off2 = 0; off2 <= 256; off2++)
{
/* forward */
char sz[32];
RTStrPrintf(sz, sizeof(sz), "memmove4-%d-%d", off1, off2);
TstBufInit(&Buf1, off1 + 1);
my_memset(Buf1.abBuf, off1, off1);
pv = RT_NOCRT(memmove)(Buf1.abBuf, &Buf1.abBuf[off2], TSTBUF_SIZE - off2); CHECK_PV(Buf1.abBuf);
if (off2 < off1)
{
unsigned cbLead = off1 - off2;
my_memcheck(Buf1.abBuf, off1, cbLead, sz);
my_memcheck(&Buf1.abBuf[cbLead], off1 + 1, TSTBUF_SIZE - cbLead, sz);
}
else
my_memcheck(Buf1.abBuf, off1 + 1, TSTBUF_SIZE, sz);
TstBufCheck(&Buf1, sz);
/* backward */
RTStrPrintf(sz, sizeof(sz), "memmove5-%d-%d", off1, off2);
TstBufInit(&Buf1, off1 + 1);
my_memset(&Buf1.abBuf[TSTBUF_SIZE - off1], off1, off1);
pv = RT_NOCRT(memmove)(&Buf1.abBuf[off2], Buf1.abBuf, TSTBUF_SIZE - off2); CHECK_PV(&Buf1.abBuf[off2]);
if (off2 < off1)
{
unsigned cbLead = off1 - off2;
my_memcheck(&Buf1.abBuf[TSTBUF_SIZE - cbLead], off1, cbLead, sz);
my_memcheck(Buf1.abBuf, off1 + 1, TSTBUF_SIZE - cbLead, sz);
}
else
my_memcheck(Buf1.abBuf, off1 + 1, TSTBUF_SIZE, sz);
TstBufCheck(&Buf1, sz);
/* small unaligned */
RTStrPrintf(sz, sizeof(sz), "memmove6-%d-%d", off1, off2);
TstBufInit(&Buf1, 1);
TstBufInit(&Buf2, 2);
size_t cb = off2;
pv = RT_NOCRT(memmove)(&Buf2.abBuf[off2], &Buf1.abBuf[off1], cb); CHECK_PV(&Buf2.abBuf[off2]);
my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, sz);
my_memcheck(Buf2.abBuf, 2, off2, sz);
my_memcheck(&Buf2.abBuf[off2], 1, cb, sz);
my_memcheck(&Buf2.abBuf[off2 + cb], 2, TSTBUF_SIZE - cb - off2, sz);
TstBufCheck(&Buf1, sz);
TstBufCheck(&Buf2, sz);
}
}
/*
* memset
*/
RTPrintf("tstNoCrt-1: memset\n");
TstBufInit(&Buf1, 1);
pv = RT_NOCRT(memset)(Buf1.abBuf, 0, TSTBUF_SIZE); CHECK_PV(Buf1.abBuf);
my_memcheck(Buf1.abBuf, 0, TSTBUF_SIZE, "memset-1");
TstBufCheck(&Buf1, "memset-1");
TstBufInit(&Buf1, 1);
pv = RT_NOCRT(memset)(Buf1.abBuf, 0xff, TSTBUF_SIZE); CHECK_PV(Buf1.abBuf);
my_memcheck(Buf1.abBuf, 0xff, TSTBUF_SIZE, "memset-2");
TstBufCheck(&Buf1, "memset-2");
TstBufInit(&Buf1, 1);
pv = RT_NOCRT(memset)(Buf1.abBuf, 0xff, 0); CHECK_PV(Buf1.abBuf);
my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, "memset-3");
TstBufCheck(&Buf1, "memset-3");
for (unsigned off = 0; off < 256; off++)
{
/* move start byte by byte. */
char sz[32];
RTStrPrintf(sz, sizeof(sz), "memset4-%d", off);
TstBufInit(&Buf1, 0);
pv = RT_NOCRT(memset)(&Buf1.abBuf[off], off, TSTBUF_SIZE - off); CHECK_PV(&Buf1.abBuf[off]);
my_memcheck(Buf1.abBuf, 0, off, sz);
my_memcheck(&Buf1.abBuf[off], off, TSTBUF_SIZE - off, sz);
TstBufCheck(&Buf1, sz);
/* move end byte by byte. */
RTStrPrintf(sz, sizeof(sz), "memset5-%d", off);
TstBufInit(&Buf1, 0);
pv = RT_NOCRT(memset)(Buf1.abBuf, off, TSTBUF_SIZE - off); CHECK_PV(Buf1.abBuf);
my_memcheck(Buf1.abBuf, off, TSTBUF_SIZE - off, sz);
my_memcheck(&Buf1.abBuf[TSTBUF_SIZE - off], 0, off, sz);
TstBufCheck(&Buf1, sz);
/* move both start and size byte by byte. */
RTStrPrintf(sz, sizeof(sz), "memset6-%d", off);
TstBufInit(&Buf1, 0);
pv = RT_NOCRT(memset)(&Buf1.abBuf[off], off, off); CHECK_PV(&Buf1.abBuf[off]);
my_memcheck(Buf1.abBuf, 0, off, sz);
my_memcheck(&Buf1.abBuf[off], off, off, sz);
my_memcheck(&Buf1.abBuf[off * 2], 0, TSTBUF_SIZE - off * 2, sz);
TstBufCheck(&Buf1, sz);
}
/*
* strcpy (quick smoke testing).
*/
RTPrintf("tstNoCrt-1: strcpy\n");
TstBufInit(&Buf1, 1);
const char *pszSrc = s_szTest1;
char *pszDst = (char *)&Buf1.abBuf[0];
pv = RT_NOCRT(strcpy)(pszDst, pszSrc);
CHECK_PV(pszDst);
TstBufCheck(&Buf1, "strcpy 1");
iDiff = RT_NOCRT(strcmp)(pszDst, pszSrc); CHECK_DIFF( == );
pszSrc = s_szTest1;
for (unsigned i = 0; i < sizeof(s_szTest1) / 2; i++)
{
pszSrc++;
TstBufInit(&Buf1, 2);
pszDst = (char *)&Buf1.abBuf[sizeof(Buf1.abBuf) - strlen(pszSrc) - 1];
pv = RT_NOCRT(strcpy)(pszDst, pszSrc);
CHECK_PV(pszDst);
TstBufCheck(&Buf1, "strcpy 3");
iDiff = RT_NOCRT(strcmp)(pszDst, pszSrc); CHECK_DIFF( == );
}
/*
* memchr & strchr.
*/
RTPrintf("tstNoCrt-1: memchr\n");
pv = RT_NOCRT(memchr)(&s_szTest1[0x00], 'f', sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0xf]);
pv = RT_NOCRT(memchr)(&s_szTest1[0x0f], 'f', sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0xf]);
pv = RT_NOCRT(memchr)(&s_szTest1[0x03], 0, sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0x10]);
pv = RT_NOCRT(memchr)(&s_szTest1[0x10], 0, sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0x10]);
pv = RT_NOCRT(memchr)(&s_szTest1, 0, ~(size_t)0); CHECK_PV(&s_szTest1[0x10]);
pv = RT_NOCRT(memchr)(&s_szTest1, 0, ~(size_t)1); CHECK_PV(&s_szTest1[0x10]);
pv = RT_NOCRT(memchr)(&s_szTest1, 0, ~(size_t)16); CHECK_PV(&s_szTest1[0x10]);
for (unsigned i = 0; i < sizeof(s_szTest1); i++)
for (unsigned j = 0; j <= i; j++)
{
pv = RT_NOCRT(memchr)(&s_szTest1[j], s_szTest1[i], sizeof(s_szTest1));
CHECK_PV(&s_szTest1[i]);
}
RTPrintf("tstNoCrt-1: strchr\n");
pv = RT_NOCRT(strchr)(&s_szTest1[0x00], 'f'); CHECK_PV(&s_szTest1[0xf]);
pv = RT_NOCRT(strchr)(&s_szTest1[0x0f], 'f'); CHECK_PV(&s_szTest1[0xf]);
pv = RT_NOCRT(strchr)(&s_szTest1[0x03], 0); CHECK_PV(&s_szTest1[0x10]);
pv = RT_NOCRT(strchr)(&s_szTest1[0x10], 0); CHECK_PV(&s_szTest1[0x10]);
for (unsigned i = 0; i < sizeof(s_szTest1); i++)
for (unsigned j = 0; j <= i; j++)
{
pv = RT_NOCRT(strchr)(&s_szTest1[j], s_szTest1[i]);
CHECK_PV(&s_szTest1[i]);
}
/*
* Some simple memcmp/strcmp checks.
*/
RTPrintf("tstNoCrt-1: memcmp\n");
iDiff = RT_NOCRT(memcmp)(s_szTest1, s_szTest1, sizeof(s_szTest1)); CHECK_DIFF( == );
iDiff = RT_NOCRT(memcmp)(s_szTest1, s_szTest2, sizeof(s_szTest1)); CHECK_DIFF( == );
iDiff = RT_NOCRT(memcmp)(s_szTest2, s_szTest1, sizeof(s_szTest1)); CHECK_DIFF( == );
iDiff = RT_NOCRT(memcmp)(s_szTest3, s_szTest3, sizeof(s_szTest1)); CHECK_DIFF( == );
iDiff = RT_NOCRT(memcmp)(s_szTest1, s_szTest3, sizeof(s_szTest1)); CHECK_DIFF( < );
iDiff = RT_NOCRT(memcmp)(s_szTest3, s_szTest1, sizeof(s_szTest1)); CHECK_DIFF( > );
iDiff = RT_NOCRT(memcmp)("1234", "1a34", 4); CHECK_DIFF( < );
RTPrintf("tstNoCrt-1: strcmp\n");
iDiff = RT_NOCRT(strcmp)(s_szTest1, s_szTest1); CHECK_DIFF( == );
iDiff = RT_NOCRT(strcmp)(s_szTest1, s_szTest2); CHECK_DIFF( == );
iDiff = RT_NOCRT(strcmp)(s_szTest2, s_szTest1); CHECK_DIFF( == );
iDiff = RT_NOCRT(strcmp)(s_szTest3, s_szTest3); CHECK_DIFF( == );
iDiff = RT_NOCRT(strcmp)(s_szTest1, s_szTest3); CHECK_DIFF( < );
iDiff = RT_NOCRT(strcmp)(s_szTest3, s_szTest1); CHECK_DIFF( > );
/*
* Some simple strlen checks.
*/
RTPrintf("tstNoCrt-1: strlen\n");
cch = RT_NOCRT(strlen)(""); CHECK_CCH(0);
cch = RT_NOCRT(strlen)("1"); CHECK_CCH(1);
cch = RT_NOCRT(strlen)("12"); CHECK_CCH(2);
cch = RT_NOCRT(strlen)("123"); CHECK_CCH(3);
cch = RT_NOCRT(strlen)("1234"); CHECK_CCH(4);
cch = RT_NOCRT(strlen)("12345"); CHECK_CCH(5);
cch = RT_NOCRT(strlen)(s_szTest1); CHECK_CCH(sizeof(s_szTest1) - 1);
cch = RT_NOCRT(strlen)(&s_szTest1[1]); CHECK_CCH(sizeof(s_szTest1) - 1 - 1);
cch = RT_NOCRT(strlen)(&s_szTest1[2]); CHECK_CCH(sizeof(s_szTest1) - 1 - 2);
cch = RT_NOCRT(strlen)(&s_szTest1[3]); CHECK_CCH(sizeof(s_szTest1) - 1 - 3);
cch = RT_NOCRT(strlen)(&s_szTest1[4]); CHECK_CCH(sizeof(s_szTest1) - 1 - 4);
cch = RT_NOCRT(strlen)(&s_szTest1[5]); CHECK_CCH(sizeof(s_szTest1) - 1 - 5);
cch = RT_NOCRT(strlen)(&s_szTest1[6]); CHECK_CCH(sizeof(s_szTest1) - 1 - 6);
cch = RT_NOCRT(strlen)(&s_szTest1[7]); CHECK_CCH(sizeof(s_szTest1) - 1 - 7);
cch = RT_NOCRT(strlen)(s_szTest2); CHECK_CCH(sizeof(s_szTest2) - 1);
cch = RT_NOCRT(strlen)(s_szTest3); CHECK_CCH(sizeof(s_szTest3) - 1);
/*
* Summary.
*/
if (!g_cErrors)
RTPrintf("tstNoCrt-1: SUCCESS\n");
else
RTPrintf("tstNoCrt-1: FAILURE - %d errors\n", g_cErrors);
return !!g_cErrors;
}
int main()
{
/*
* Init runtime
*/
unsigned cErrors = 0;
int rc = RTR3InitExeNoArguments(0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/*
* Check that the clock is reliable.
*/
RTPrintf("tstTimer: TESTING - RTTimeNanoTS() for 2sec\n");
uint64_t uTSMillies = RTTimeMilliTS();
uint64_t uTSBegin = RTTimeNanoTS();
uint64_t uTSLast = uTSBegin;
uint64_t uTSDiff;
uint64_t cIterations = 0;
do
{
uint64_t uTS = RTTimeNanoTS();
if (uTS < uTSLast)
{
RTPrintf("tstTimer: FAILURE - RTTimeNanoTS() is unreliable. uTS=%RU64 uTSLast=%RU64\n", uTS, uTSLast);
cErrors++;
}
if (++cIterations > (2*1000*1000*1000))
{
RTPrintf("tstTimer: FAILURE - RTTimeNanoTS() is unreliable. cIterations=%RU64 uTS=%RU64 uTSBegin=%RU64\n", cIterations, uTS, uTSBegin);
return 1;
}
uTSLast = uTS;
uTSDiff = uTSLast - uTSBegin;
} while (uTSDiff < (2*1000*1000*1000));
uTSMillies = RTTimeMilliTS() - uTSMillies;
if (uTSMillies >= 2500 || uTSMillies <= 1500)
{
RTPrintf("tstTimer: FAILURE - uTSMillies=%RI64 uTSBegin=%RU64 uTSLast=%RU64 uTSDiff=%RU64\n",
uTSMillies, uTSBegin, uTSLast, uTSDiff);
cErrors++;
}
if (!cErrors)
RTPrintf("tstTimer: OK - RTTimeNanoTS()\n");
/*
* Tests.
*/
static struct
{
unsigned uMicroInterval;
unsigned uMilliesWait;
unsigned cLower;
unsigned cUpper;
} aTests[] =
{
{ 32000, 2000, 0, 0 },
{ 20000, 2000, 0, 0 },
{ 10000, 2000, 0, 0 },
{ 8000, 2000, 0, 0 },
{ 2000, 2000, 0, 0 },
{ 1000, 2000, 0, 0 },
{ 500, 5000, 0, 0 },
{ 200, 5000, 0, 0 },
{ 100, 5000, 0, 0 }
};
unsigned i = 0;
for (i = 0; i < RT_ELEMENTS(aTests); i++)
{
aTests[i].cLower = (aTests[i].uMilliesWait*1000 - aTests[i].uMilliesWait*100) / aTests[i].uMicroInterval;
aTests[i].cUpper = (aTests[i].uMilliesWait*1000 + aTests[i].uMilliesWait*100) / aTests[i].uMicroInterval;
gu64Norm = aTests[i].uMicroInterval*1000;
RTPrintf("\n"
"tstTimer: TESTING - %d us interval, %d ms wait, expects %d-%d ticks.\n",
aTests[i].uMicroInterval, aTests[i].uMilliesWait, aTests[i].cLower, aTests[i].cUpper);
/*
* Start timer which ticks every 10ms.
*/
gcTicks = 0;
PRTTIMER pTimer;
gu64Max = 0;
gu64Min = UINT64_MAX;
gu64Prev = 0;
RT_ZERO(cFrequency);
#ifdef RT_OS_WINDOWS
if (aTests[i].uMicroInterval < 1000)
continue;
rc = RTTimerCreate(&pTimer, aTests[i].uMicroInterval / 1000, TimerCallback, NULL);
#else
rc = RTTimerCreateEx(&pTimer, aTests[i].uMicroInterval * (uint64_t)1000, 0, TimerCallback, NULL);
#endif
if (RT_FAILURE(rc))
{
RTPrintf("tstTimer: FAILURE - RTTimerCreateEx(,%u*1M,,,) -> %Rrc\n", aTests[i].uMicroInterval, rc);
cErrors++;
continue;
}
/*
* Start the timer and active waiting for the requested test period.
*/
uTSBegin = RTTimeNanoTS();
#ifndef RT_OS_WINDOWS
rc = RTTimerStart(pTimer, 0);
if (RT_FAILURE(rc))
{
RTPrintf("tstTimer: FAILURE - RTTimerStart(,0) -> %Rrc\n", rc);
cErrors++;
}
#endif
while (RTTimeNanoTS() - uTSBegin < (uint64_t)aTests[i].uMilliesWait * 1000000)
/* nothing */;
/* destroy the timer */
uint64_t uTSEnd = RTTimeNanoTS();
uTSDiff = uTSEnd - uTSBegin;
rc = RTTimerDestroy(pTimer);
if (RT_FAILURE(rc))
{
RTPrintf("tstTimer: FAILURE - RTTimerDestroy() -> %d gcTicks=%d\n", rc, gcTicks);
cErrors++;
}
RTPrintf("tstTimer: uTS=%RI64 (%RU64 - %RU64)\n", uTSDiff, uTSBegin, uTSEnd);
unsigned cTicks = gcTicks;
RTThreadSleep(aTests[i].uMicroInterval/1000 * 3);
if (gcTicks != cTicks)
{
RTPrintf("tstTimer: FAILURE - RTTimerDestroy() didn't really stop the timer! gcTicks=%d cTicks=%d\n", gcTicks, cTicks);
cErrors++;
continue;
}
/*
* Check the number of ticks.
*/
if (gcTicks < aTests[i].cLower)
{
RTPrintf("tstTimer: FAILURE - Too few ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
cErrors++;
}
else if (gcTicks > aTests[i].cUpper)
{
RTPrintf("tstTimer: FAILURE - Too many ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
cErrors++;
}
else
RTPrintf("tstTimer: OK - gcTicks=%d", gcTicks);
RTPrintf(" min=%RU64 max=%RU64\n", gu64Min, gu64Max);
for (int j = 0; j < (int)RT_ELEMENTS(cFrequency); j++)
{
uint32_t len = cFrequency[j] * 70 / gcTicks;
uint32_t deviation = j - RT_ELEMENTS(cFrequency) / 2;
uint64_t u64FreqPercent = (uint64_t)cFrequency[j] * 10000 / gcTicks;
uint64_t u64FreqPercentFrac = u64FreqPercent % 100;
u64FreqPercent = u64FreqPercent / 100;
RTPrintf("%+4d%c %6u %3llu.%02llu%% ",
deviation, deviation == 0 ? ' ' : '%', cFrequency[j],
u64FreqPercent, u64FreqPercentFrac);
for (unsigned k = 0; k < len; k++)
RTPrintf("*");
RTPrintf("\n");
}
}
/*
* Summary.
*/
if (!cErrors)
RTPrintf("tstTimer: SUCCESS\n");
else
RTPrintf("tstTimer: FAILURE %d errors\n", cErrors);
return !!cErrors;
}
int main()
{
/*
* Init.
*/
int rc = RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
RTTEST hTest;
rc = RTTestCreate("tstRTTime", &hTest);
if (RT_FAILURE(rc))
return RTEXITCODE_FAILURE;
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
{
RTTestValue(hTest, "Total time delta", u64OSElapsedTS - u64RTElapsedTS, 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);
}
int main()
{
RTR3InitExeNoArguments(0);
int cErrors = 0;
static const struct TstU64 aTstU64[] =
{
{ "0", 0, VINF_SUCCESS, 0 },
{ "1", 0, VINF_SUCCESS, 1 },
{ "-1", 0, VWRN_NEGATIVE_UNSIGNED, ~0ULL },
{ "0x", 0, VWRN_TRAILING_CHARS, 0 },
{ "0x1", 0, VINF_SUCCESS, 1 },
{ "0x0fffffffffffffff", 0, VINF_SUCCESS, 0x0fffffffffffffffULL },
{ "0x0ffffffffffffffffffffff",0, VWRN_NUMBER_TOO_BIG, 0xffffffffffffffffULL },
{ "asdfasdfasdf", 0, VERR_NO_DIGITS, 0 },
{ "0x111111111", 0, VINF_SUCCESS, 0x111111111ULL },
{ "4D9702C5CBD9B778", 16, VINF_SUCCESS, UINT64_C(0x4D9702C5CBD9B778) },
};
RUN_TESTS(aTstU64, uint64_t, "%#llx", RTStrToUInt64Ex);
static const struct TstI64 aTstI64[] =
{
{ "0", 0, VINF_SUCCESS, 0 },
{ "1", 0, VINF_SUCCESS, 1 },
{ "-1", 0, VINF_SUCCESS, -1 },
{ "-1", 10, VINF_SUCCESS, -1 },
{ "-31", 0, VINF_SUCCESS, -31 },
{ "-31", 10, VINF_SUCCESS, -31 },
{ "-32", 0, VINF_SUCCESS, -32 },
{ "-33", 0, VINF_SUCCESS, -33 },
{ "-64", 0, VINF_SUCCESS, -64 },
{ "-127", 0, VINF_SUCCESS, -127 },
{ "-128", 0, VINF_SUCCESS, -128 },
{ "-129", 0, VINF_SUCCESS, -129 },
{ "-254", 0, VINF_SUCCESS, -254 },
{ "-255", 0, VINF_SUCCESS, -255 },
{ "-256", 0, VINF_SUCCESS, -256 },
{ "-257", 0, VINF_SUCCESS, -257 },
{ "-511", 0, VINF_SUCCESS, -511 },
{ "-512", 0, VINF_SUCCESS, -512 },
{ "-513", 0, VINF_SUCCESS, -513 },
{ "-1023", 0, VINF_SUCCESS, -1023 },
{ "-1023", 0, VINF_SUCCESS, -1023 },
{ "-1023", 0, VINF_SUCCESS, -1023},
{ "-1023", 10, VINF_SUCCESS, -1023 },
{ "-4564678", 0, VINF_SUCCESS, -4564678 },
{ "-4564678", 10, VINF_SUCCESS, -4564678 },
{ "-1234567890123456789", 0, VINF_SUCCESS, -1234567890123456789LL },
{ "-1234567890123456789", 10, VINF_SUCCESS, -1234567890123456789LL },
{ "0x", 0, VWRN_TRAILING_CHARS, 0 },
{ "0x1", 0, VINF_SUCCESS, 1 },
{ "0x1", 10, VWRN_TRAILING_CHARS, 0 },
{ "0x1", 16, VINF_SUCCESS, 1 },
{ "0x0fffffffffffffff", 0, VINF_SUCCESS, 0x0fffffffffffffffULL },
{ "0x7fffffffffffffff", 0, VINF_SUCCESS, 0x7fffffffffffffffULL },
{ "0xffffffffffffffff", 0, VWRN_NUMBER_TOO_BIG, -1 },
{ "0x01111111111111111111111",0, VWRN_NUMBER_TOO_BIG, 0x1111111111111111ULL },
{ "0x02222222222222222222222",0, VWRN_NUMBER_TOO_BIG, 0x2222222222222222ULL },
{ "0x03333333333333333333333",0, VWRN_NUMBER_TOO_BIG, 0x3333333333333333ULL },
{ "0x04444444444444444444444",0, VWRN_NUMBER_TOO_BIG, 0x4444444444444444ULL },
{ "0x07777777777777777777777",0, VWRN_NUMBER_TOO_BIG, 0x7777777777777777ULL },
{ "0x07f7f7f7f7f7f7f7f7f7f7f",0, VWRN_NUMBER_TOO_BIG, 0x7f7f7f7f7f7f7f7fULL },
{ "0x0ffffffffffffffffffffff",0, VWRN_NUMBER_TOO_BIG, (int64_t)0xffffffffffffffffULL },
{ "asdfasdfasdf", 0, VERR_NO_DIGITS, 0 },
{ "0x111111111", 0, VINF_SUCCESS, 0x111111111ULL },
};
RUN_TESTS(aTstI64, int64_t, "%#lld", RTStrToInt64Ex);
static const struct TstI32 aTstI32[] =
{
{ "0", 0, VINF_SUCCESS, 0 },
{ "1", 0, VINF_SUCCESS, 1 },
{ "-1", 0, VINF_SUCCESS, -1 },
{ "-1", 10, VINF_SUCCESS, -1 },
{ "-31", 0, VINF_SUCCESS, -31 },
{ "-31", 10, VINF_SUCCESS, -31 },
{ "-32", 0, VINF_SUCCESS, -32 },
{ "-33", 0, VINF_SUCCESS, -33 },
{ "-64", 0, VINF_SUCCESS, -64 },
{ "-127", 0, VINF_SUCCESS, -127 },
{ "-128", 0, VINF_SUCCESS, -128 },
{ "-129", 0, VINF_SUCCESS, -129 },
{ "-254", 0, VINF_SUCCESS, -254 },
{ "-255", 0, VINF_SUCCESS, -255 },
{ "-256", 0, VINF_SUCCESS, -256 },
{ "-257", 0, VINF_SUCCESS, -257 },
{ "-511", 0, VINF_SUCCESS, -511 },
{ "-512", 0, VINF_SUCCESS, -512 },
{ "-513", 0, VINF_SUCCESS, -513 },
{ "-1023", 0, VINF_SUCCESS, -1023 },
{ "-1023", 0, VINF_SUCCESS, -1023 },
{ "-1023", 0, VINF_SUCCESS, -1023},
{ "-1023", 10, VINF_SUCCESS, -1023 },
{ "-4564678", 0, VINF_SUCCESS, -4564678 },
{ "-4564678", 10, VINF_SUCCESS, -4564678 },
{ "4564678", 0, VINF_SUCCESS, 4564678 },
{ "4564678", 10, VINF_SUCCESS, 4564678 },
{ "-1234567890123456789", 0, VWRN_NUMBER_TOO_BIG, (int32_t)((uint64_t)INT64_C(-1234567890123456789) & UINT32_MAX) },
{ "-1234567890123456789", 10, VWRN_NUMBER_TOO_BIG, (int32_t)((uint64_t)INT64_C(-1234567890123456789) & UINT32_MAX) },
{ "1234567890123456789", 0, VWRN_NUMBER_TOO_BIG, (int32_t)(INT64_C(1234567890123456789) & UINT32_MAX) },
{ "1234567890123456789", 10, VWRN_NUMBER_TOO_BIG, (int32_t)(INT64_C(1234567890123456789) & UINT32_MAX) },
{ "0x", 0, VWRN_TRAILING_CHARS, 0 },
{ "0x1", 0, VINF_SUCCESS, 1 },
{ "0x1", 10, VWRN_TRAILING_CHARS, 0 },
{ "0x1", 16, VINF_SUCCESS, 1 },
{ "0x7fffffff", 0, VINF_SUCCESS, 0x7fffffff },
{ "0x80000000", 0, VWRN_NUMBER_TOO_BIG, INT32_MIN },
{ "0xffffffff", 0, VWRN_NUMBER_TOO_BIG, -1 },
{ "0x0fffffffffffffff", 0, VWRN_NUMBER_TOO_BIG, (int32_t)0xffffffff },
{ "0x01111111111111111111111",0, VWRN_NUMBER_TOO_BIG, 0x11111111 },
{ "0x0ffffffffffffffffffffff",0, VWRN_NUMBER_TOO_BIG, (int32_t)0xffffffff },
{ "asdfasdfasdf", 0, VERR_NO_DIGITS, 0 },
{ "0x1111111", 0, VINF_SUCCESS, 0x01111111 },
};
RUN_TESTS(aTstI32, int32_t, "%#d", RTStrToInt32Ex);
static const struct TstU32 aTstU32[] =
{
{ "0", 0, VINF_SUCCESS, 0 },
{ "1", 0, VINF_SUCCESS, 1 },
/// @todo { "-1", 0, VWRN_NEGATIVE_UNSIGNED, ~0 }, - no longer true. bad idea?
{ "-1", 0, VWRN_NUMBER_TOO_BIG, ~0U },
{ "0x", 0, VWRN_TRAILING_CHARS, 0 },
{ "0x1", 0, VINF_SUCCESS, 1 },
{ "0x0fffffffffffffff", 0, VWRN_NUMBER_TOO_BIG, 0xffffffffU },
{ "0x0ffffffffffffffffffffff",0, VWRN_NUMBER_TOO_BIG, 0xffffffffU },
{ "asdfasdfasdf", 0, VERR_NO_DIGITS, 0 },
{ "0x1111111", 0, VINF_SUCCESS, 0x1111111 },
};
RUN_TESTS(aTstU32, uint32_t, "%#x", RTStrToUInt32Ex);
/*
* Summary.
*/
if (!cErrors)
RTPrintf("tstStrToNum: SUCCESS\n");
else
RTPrintf("tstStrToNum: FAILURE - %d errors\n", cErrors);
return !!cErrors;
}
int main()
{
RTR3InitExeNoArguments(0);
RTPrintf("tstMp-1: TESTING...\n");
/*
* Present and possible CPUs.
*/
RTCPUID cCpus = RTMpGetCount();
if (cCpus > 0)
RTPrintf("tstMp-1: RTMpGetCount -> %d\n", (int)cCpus);
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetCount -> %d\n", (int)cCpus);
g_cErrors++;
cCpus = 1;
}
RTCPUSET Set;
PRTCPUSET pSet = RTMpGetSet(&Set);
if (pSet == &Set)
{
if ((RTCPUID)RTCpuSetCount(&Set) != cCpus)
{
RTPrintf("tstMp-1: FAILURE: RTMpGetSet returned a set with a different cpu count; %d, expected %d\n",
RTCpuSetCount(&Set), cCpus);
g_cErrors++;
}
RTPrintf("tstMp-1: Possible CPU mask:\n");
for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
{
RTCPUID idCpu = RTMpCpuIdFromSetIndex(iCpu);
if (RTCpuSetIsMemberByIndex(&Set, iCpu))
{
RTPrintf("tstMp-1: %2d - id %d: %u/%u MHz", iCpu, (int)idCpu,
RTMpGetCurFrequency(idCpu), RTMpGetMaxFrequency(idCpu));
if (RTMpIsCpuPresent(idCpu))
RTPrintf(RTMpIsCpuOnline(idCpu) ? " online\n" : " offline\n");
else
{
if (!RTMpIsCpuOnline(idCpu))
RTPrintf(" absent\n");
else
{
RTPrintf(" online but absent!\n");
RTPrintf("tstMp-1: FAILURE: Cpu with index %d is report as !RTIsCpuPresent while RTIsCpuOnline returns true!\n", iCpu);
g_cErrors++;
}
}
if (!RTMpIsCpuPossible(idCpu))
{
RTPrintf("tstMp-1: FAILURE: Cpu with index %d is returned by RTCpuSet but not RTMpIsCpuPossible!\n", iCpu);
g_cErrors++;
}
}
else if (RTMpIsCpuPossible(idCpu))
{
RTPrintf("tstMp-1: FAILURE: Cpu with index %d is returned by RTMpIsCpuPossible but not RTCpuSet!\n", iCpu);
g_cErrors++;
}
else if (RTMpGetCurFrequency(idCpu) != 0)
{
RTPrintf("tstMp-1: FAILURE: RTMpGetCurFrequency(%d[idx=%d]) didn't return 0 as it should\n", (int)idCpu, iCpu);
g_cErrors++;
}
else if (RTMpGetMaxFrequency(idCpu) != 0)
{
RTPrintf("tstMp-1: FAILURE: RTMpGetMaxFrequency(%d[idx=%d]) didn't return 0 as it should\n", (int)idCpu, iCpu);
g_cErrors++;
}
}
}
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetSet -> %p, expected %p\n", pSet, &Set);
g_cErrors++;
RTCpuSetEmpty(&Set);
RTCpuSetAdd(&Set, RTMpCpuIdFromSetIndex(0));
}
/*
* Online CPUs.
*/
RTCPUID cCpusOnline = RTMpGetOnlineCount();
if (cCpusOnline > 0)
{
if (cCpusOnline <= cCpus)
RTPrintf("tstMp-1: RTMpGetOnlineCount -> %d\n", (int)cCpusOnline);
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineCount -> %d, expected <= %d\n", (int)cCpusOnline, (int)cCpus);
g_cErrors++;
cCpusOnline = cCpus;
}
}
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineCount -> %d\n", (int)cCpusOnline);
g_cErrors++;
cCpusOnline = 1;
}
RTCPUSET SetOnline;
pSet = RTMpGetOnlineSet(&SetOnline);
if (pSet == &SetOnline)
{
if (RTCpuSetCount(&SetOnline) <= 0)
{
RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet returned an empty set!\n");
g_cErrors++;
}
else if ((RTCPUID)RTCpuSetCount(&SetOnline) > cCpus)
{
RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet returned a too high value; %d, expected <= %d\n",
RTCpuSetCount(&SetOnline), cCpus);
g_cErrors++;
}
RTPrintf("tstMp-1: Online CPU mask:\n");
for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
if (RTCpuSetIsMemberByIndex(&SetOnline, iCpu))
{
RTCPUID idCpu = RTMpCpuIdFromSetIndex(iCpu);
RTPrintf("tstMp-1: %2d - id %d: %u/%u MHz %s\n", iCpu, (int)idCpu, RTMpGetCurFrequency(idCpu),
RTMpGetMaxFrequency(idCpu), RTMpIsCpuOnline(idCpu) ? "online" : "offline");
if (!RTCpuSetIsMemberByIndex(&Set, iCpu))
{
RTPrintf("tstMp-1: FAILURE: online cpu with index %2d is not a member of the possible cpu set!\n", iCpu);
g_cErrors++;
}
}
/* There isn't any sane way of testing RTMpIsCpuOnline really... :-/ */
}
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet -> %p, expected %p\n", pSet, &Set);
g_cErrors++;
}
/*
* Present CPUs.
*/
RTCPUID cCpusPresent = RTMpGetPresentCount();
if (cCpusPresent > 0)
{
if ( cCpusPresent <= cCpus
&& cCpusPresent >= cCpusOnline)
RTPrintf("tstMp-1: RTMpGetPresentCount -> %d\n", (int)cCpusPresent);
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetPresentCount -> %d, expected <= %d and >= %d\n", (int)cCpusPresent, (int)cCpus, (int)cCpusOnline);
g_cErrors++;
}
}
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetPresentCount -> %d\n", (int)cCpusPresent);
g_cErrors++;
cCpusPresent = 1;
}
RTCPUSET SetPresent;
pSet = RTMpGetPresentSet(&SetPresent);
if (pSet == &SetPresent)
{
if (RTCpuSetCount(&SetPresent) <= 0)
{
RTPrintf("tstMp-1: FAILURE: RTMpGetPresentSet returned an empty set!\n");
g_cErrors++;
}
else if ((RTCPUID)RTCpuSetCount(&SetPresent) != cCpusPresent)
{
RTPrintf("tstMp-1: FAILURE: RTMpGetPresentSet returned a bad value; %d, expected = %d\n",
RTCpuSetCount(&SetPresent), cCpusPresent);
g_cErrors++;
}
RTPrintf("tstMp-1: Present CPU mask:\n");
for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
if (RTCpuSetIsMemberByIndex(&SetPresent, iCpu))
{
RTCPUID idCpu = RTMpCpuIdFromSetIndex(iCpu);
RTPrintf("tstMp-1: %2d - id %d: %u/%u MHz %s\n", iCpu, (int)idCpu, RTMpGetCurFrequency(idCpu),
RTMpGetMaxFrequency(idCpu), RTMpIsCpuPresent(idCpu) ? "present" : "absent");
if (!RTCpuSetIsMemberByIndex(&Set, iCpu))
{
RTPrintf("tstMp-1: FAILURE: online cpu with index %2d is not a member of the possible cpu set!\n", iCpu);
g_cErrors++;
}
}
/* There isn't any sane way of testing RTMpIsCpuPresent really... :-/ */
}
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetPresentSet -> %p, expected %p\n", pSet, &Set);
g_cErrors++;
}
/* Find an online cpu for the next test. */
RTCPUID idCpuOnline;
for (idCpuOnline = 0; idCpuOnline < RTCPUSET_MAX_CPUS; idCpuOnline++)
if (RTMpIsCpuOnline(idCpuOnline))
break;
/*
* Quick test of RTMpGetDescription.
*/
char szBuf[64];
int rc = RTMpGetDescription(idCpuOnline, &szBuf[0], sizeof(szBuf));
if (RT_SUCCESS(rc))
{
RTPrintf("tstMp-1: RTMpGetDescription -> '%s'\n", szBuf);
size_t cch = strlen(szBuf);
rc = RTMpGetDescription(idCpuOnline, &szBuf[0], cch);
if (rc != VERR_BUFFER_OVERFLOW)
{
RTPrintf("tstMp-1: FAILURE: RTMpGetDescription -> %Rrc, expected VERR_BUFFER_OVERFLOW\n", rc);
g_cErrors++;
}
rc = RTMpGetDescription(idCpuOnline, &szBuf[0], cch + 1);
if (RT_FAILURE(rc))
{
RTPrintf("tstMp-1: FAILURE: RTMpGetDescription -> %Rrc, expected VINF_SUCCESS\n", rc);
g_cErrors++;
}
}
else
{
RTPrintf("tstMp-1: FAILURE: RTMpGetDescription -> %Rrc\n", rc);
g_cErrors++;
}
if (!g_cErrors)
RTPrintf("tstMp-1: SUCCESS\n", g_cErrors);
else
RTPrintf("tstMp-1: FAILURE - %d errors\n", g_cErrors);
return !!g_cErrors;
}
int main()
{
RTR3InitExeNoArguments(0);
RTPrintf("tstRand: TESTING...\n");
/*
* Do some smoke tests first?
*/
/** @todo RTRand smoke testing. */
#if 1
/*
* Test distribution.
*/
#if 1
/* unsigned 32-bit */
static const struct
{
uint32_t u32First;
uint32_t u32Last;
} s_aU32Tests[] =
{
{ 0, UINT32_MAX },
{ 0, UINT32_MAX / 2 + UINT32_MAX / 4 },
{ 0, UINT32_MAX / 2 + UINT32_MAX / 8 },
{ 0, UINT32_MAX / 2 + UINT32_MAX / 16 },
{ 0, UINT32_MAX / 2 + UINT32_MAX / 64 },
{ 0, UINT32_MAX / 2 },
{ UINT32_MAX / 4, UINT32_MAX / 4 * 3 },
{ 0, TST_RAND_SAMPLE_RANGES - 1 },
{ 1234, 1234 + TST_RAND_SAMPLE_RANGES - 1 },
};
for (unsigned iTest = 0; iTest < RT_ELEMENTS(s_aU32Tests); iTest++)
{
uint32_t acHits[TST_RAND_SAMPLE_RANGES] = {0};
uint32_t const uFirst = s_aU32Tests[iTest].u32First;
uint32_t const uLast = s_aU32Tests[iTest].u32Last;
uint32_t const uRange = uLast - uFirst; Assert(uLast >= uFirst);
uint32_t const uDivisor = uRange / TST_RAND_SAMPLE_RANGES + 1;
RTPrintf("tstRand: TESTING RTRandU32Ex(%#RX32, %#RX32) distribution... [div=%#RX32 range=%#RX32]\n", uFirst, uLast, uDivisor, uRange);
for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
{
uint32_t uRand = RTRandU32Ex(uFirst, uLast);
CHECK_EXPR_MSG(uRand >= uFirst, ("%#RX32 %#RX32\n", uRand, uFirst));
CHECK_EXPR_MSG(uRand <= uLast, ("%#RX32 %#RX32\n", uRand, uLast));
uint32_t off = uRand - uFirst;
acHits[off / uDivisor]++;
}
tstRandCheckDist(acHits, iTest);
}
#endif
#if 1
/* unsigned 64-bit */
static const struct
{
uint64_t u64First;
uint64_t u64Last;
} s_aU64Tests[] =
{
{ 0, UINT64_MAX },
{ 0, UINT64_MAX / 2 + UINT64_MAX / 4 },
{ 0, UINT64_MAX / 2 + UINT64_MAX / 8 },
{ 0, UINT64_MAX / 2 + UINT64_MAX / 16 },
{ 0, UINT64_MAX / 2 + UINT64_MAX / 64 },
{ 0, UINT64_MAX / 2 },
{ UINT64_MAX / 4, UINT64_MAX / 4 * 3 },
{ 0, UINT32_MAX },
{ 0, UINT32_MAX / 2 + UINT32_MAX / 4 },
{ 0, UINT32_MAX / 2 + UINT32_MAX / 8 },
{ 0, UINT32_MAX / 2 + UINT32_MAX / 16 },
{ 0, UINT32_MAX / 2 + UINT32_MAX / 64 },
{ 0, UINT32_MAX / 2 },
{ UINT32_MAX / 4, UINT32_MAX / 4 * 3 },
{ 0, TST_RAND_SAMPLE_RANGES - 1 },
{ 1234, 1234 + TST_RAND_SAMPLE_RANGES - 1 },
};
for (unsigned iTest = 0; iTest < RT_ELEMENTS(s_aU64Tests); iTest++)
{
uint32_t acHits[TST_RAND_SAMPLE_RANGES] = {0};
uint64_t const uFirst = s_aU64Tests[iTest].u64First;
uint64_t const uLast = s_aU64Tests[iTest].u64Last;
uint64_t const uRange = uLast - uFirst; Assert(uLast >= uFirst);
uint64_t const uDivisor = uRange / TST_RAND_SAMPLE_RANGES + 1;
RTPrintf("tstRand: TESTING RTRandU64Ex(%#RX64, %#RX64) distribution... [div=%#RX64 range=%#RX64]\n", uFirst, uLast, uDivisor, uRange);
for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
{
uint64_t uRand = RTRandU64Ex(uFirst, uLast);
CHECK_EXPR_MSG(uRand >= uFirst, ("%#RX64 %#RX64\n", uRand, uFirst));
CHECK_EXPR_MSG(uRand <= uLast, ("%#RX64 %#RX64\n", uRand, uLast));
uint64_t off = uRand - uFirst;
acHits[off / uDivisor]++;
}
tstRandCheckDist(acHits, iTest);
}
#endif
#if 1
/* signed 32-bit */
static const struct
{
int32_t i32First;
int32_t i32Last;
} s_aS32Tests[] =
{
{ -429496729, 429496729 },
{ INT32_MIN, INT32_MAX },
{ INT32_MIN, INT32_MAX / 2 },
{ -0x20000000, INT32_MAX },
{ -0x10000000, INT32_MAX },
{ -0x08000000, INT32_MAX },
{ -0x00800000, INT32_MAX },
{ -0x00080000, INT32_MAX },
{ -0x00008000, INT32_MAX },
{ -0x00000800, INT32_MAX },
{ 2, INT32_MAX / 2 },
{ 4000000, INT32_MAX / 2 },
{ -4000000, INT32_MAX / 2 },
{ INT32_MIN / 2, INT32_MAX / 2 },
{ INT32_MIN / 3, INT32_MAX / 2 },
{ INT32_MIN / 3, INT32_MAX / 3 },
{ INT32_MIN / 3, INT32_MAX / 4 },
{ INT32_MIN / 4, INT32_MAX / 4 },
{ INT32_MIN / 5, INT32_MAX / 5 },
{ INT32_MIN / 6, INT32_MAX / 6 },
{ INT32_MIN / 7, INT32_MAX / 6 },
{ INT32_MIN / 7, INT32_MAX / 7 },
{ INT32_MIN / 7, INT32_MAX / 8 },
{ INT32_MIN / 8, INT32_MAX / 8 },
{ INT32_MIN / 9, INT32_MAX / 9 },
{ INT32_MIN / 9, INT32_MAX / 12 },
{ INT32_MIN / 12, INT32_MAX / 12 },
{ 0, TST_RAND_SAMPLE_RANGES - 1 },
{ -TST_RAND_SAMPLE_RANGES / 2, TST_RAND_SAMPLE_RANGES / 2 - 1 },
};
for (unsigned iTest = 0; iTest < RT_ELEMENTS(s_aS32Tests); iTest++)
{
uint32_t acHits[TST_RAND_SAMPLE_RANGES] = {0};
int32_t const iFirst = s_aS32Tests[iTest].i32First;
int32_t const iLast = s_aS32Tests[iTest].i32Last;
uint32_t const uRange = iLast - iFirst; AssertMsg(iLast >= iFirst, ("%d\n", iTest));
uint32_t const uDivisor = (uRange ? uRange : UINT32_MAX) / TST_RAND_SAMPLE_RANGES + 1;
RTPrintf("tstRand: TESTING RTRandS32Ex(%#RI32, %#RI32) distribution... [div=%#RX32 range=%#RX32]\n", iFirst, iLast, uDivisor, uRange);
for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
{
int32_t iRand = RTRandS32Ex(iFirst, iLast);
CHECK_EXPR_MSG(iRand >= iFirst, ("%#RI32 %#RI32\n", iRand, iFirst));
CHECK_EXPR_MSG(iRand <= iLast, ("%#RI32 %#RI32\n", iRand, iLast));
uint32_t off = iRand - iFirst;
acHits[off / uDivisor]++;
}
tstRandCheckDist(acHits, iTest);
}
#endif
#if 1
/* signed 64-bit */
static const struct
{
int64_t i64First;
int64_t i64Last;
} s_aS64Tests[] =
{
{ INT64_MIN, INT64_MAX },
{ INT64_MIN, INT64_MAX / 2 },
{ INT64_MIN / 2, INT64_MAX / 2 },
{ INT64_MIN / 2 + INT64_MIN / 4, INT64_MAX / 2 },
{ INT64_MIN / 2 + INT64_MIN / 8, INT64_MAX / 2 },
{ INT64_MIN / 2 + INT64_MIN / 16, INT64_MAX / 2 },
{ INT64_MIN / 2 + INT64_MIN / 64, INT64_MAX / 2 },
{ INT64_MIN / 2 + INT64_MIN / 64, INT64_MAX / 2 + INT64_MAX / 64 },
{ INT64_MIN / 2, INT64_MAX / 2 + INT64_MAX / 64 },
{ INT64_MIN / 2, INT64_MAX / 2 + INT64_MAX / 8 },
{ INT64_MIN / 2, INT64_MAX / 2 - INT64_MAX / 8 },
{ INT64_MIN / 2 - INT64_MIN / 4, INT64_MAX / 2 - INT64_MAX / 4 },
{ INT64_MIN / 2 - INT64_MIN / 4, INT64_MAX / 2 - INT64_MAX / 8 },
{ INT64_MIN / 2 - INT64_MIN / 8, INT64_MAX / 2 - INT64_MAX / 8 },
{ INT64_MIN / 2 - INT64_MIN / 16, INT64_MAX / 2 - INT64_MAX / 8 },
{ INT64_MIN / 2 - INT64_MIN / 16, INT64_MAX / 2 - INT64_MAX / 16 },
{ INT64_MIN / 2 - INT64_MIN / 32, INT64_MAX / 2 - INT64_MAX / 16 },
{ INT64_MIN / 2 - INT64_MIN / 32, INT64_MAX / 2 - INT64_MAX / 32 },
{ INT64_MIN / 2 - INT64_MIN / 64, INT64_MAX / 2 - INT64_MAX / 64 },
{ INT64_MIN / 2 - INT64_MIN / 8, INT64_MAX / 2 },
{ INT64_MIN / 4, INT64_MAX / 4 },
{ INT64_MIN / 5, INT64_MAX / 5 },
{ INT64_MIN / 6, INT64_MAX / 6 },
{ INT64_MIN / 7, INT64_MAX / 7 },
{ INT64_MIN / 8, INT64_MAX / 8 },
{ INT32_MIN, INT32_MAX },
{ INT32_MIN, INT32_MAX / 2 },
{ -0x20000000, INT32_MAX },
{ -0x10000000, INT32_MAX },
{ -0x7f000000, INT32_MAX },
{ -0x08000000, INT32_MAX },
{ -0x00800000, INT32_MAX },
{ -0x00080000, INT32_MAX },
{ -0x00008000, INT32_MAX },
{ 2, INT32_MAX / 2 },
{ 4000000, INT32_MAX / 2 },
{ -4000000, INT32_MAX / 2 },
{ INT32_MIN / 2, INT32_MAX / 2 },
{ 0, TST_RAND_SAMPLE_RANGES - 1 },
{ -TST_RAND_SAMPLE_RANGES / 2, TST_RAND_SAMPLE_RANGES / 2 - 1 }
};
for (unsigned iTest = 0; iTest < RT_ELEMENTS(s_aS64Tests); iTest++)
{
uint32_t acHits[TST_RAND_SAMPLE_RANGES] = {0};
int64_t const iFirst = s_aS64Tests[iTest].i64First;
int64_t const iLast = s_aS64Tests[iTest].i64Last;
uint64_t const uRange = iLast - iFirst; AssertMsg(iLast >= iFirst, ("%d\n", iTest));
uint64_t const uDivisor = (uRange ? uRange : UINT64_MAX) / TST_RAND_SAMPLE_RANGES + 1;
RTPrintf("tstRand: TESTING RTRandS64Ex(%#RI64, %#RI64) distribution... [div=%#RX64 range=%#016RX64]\n", iFirst, iLast, uDivisor, uRange);
for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
{
int64_t iRand = RTRandS64Ex(iFirst, iLast);
CHECK_EXPR_MSG(iRand >= iFirst, ("%#RI64 %#RI64\n", iRand, iFirst));
CHECK_EXPR_MSG(iRand <= iLast, ("%#RI64 %#RI64\n", iRand, iLast));
uint64_t off = iRand - iFirst;
acHits[off / uDivisor]++;
}
tstRandCheckDist(acHits, iTest);
}
#endif
#endif /* Testing RTRand */
#if 1
/*
* Test the various random generators.
*/
RTPrintf("tstRand: TESTING RTRandAdvCreateParkerMiller\n");
RTRAND hRand;
int rc = RTRandAdvCreateParkMiller(&hRand);
CHECK_EXPR_MSG(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc));
if (RT_SUCCESS(rc))
if (tstRandAdv(hRand))
return 1;
#endif /* Testing RTRandAdv */
/*
* Summary.
*/
if (!g_cErrors)
RTPrintf("tstRand: SUCCESS\n");
else
RTPrintf("tstRand: FAILED - %d errors\n", g_cErrors);
return !!g_cErrors;
}
int main()
{
RTR3InitExeNoArguments(0);
/*
* Just a simple testcase.
*/
RTPrintf("tstOnce: TESTING - smoke...\n");
RTONCE Once1 = RTONCE_INITIALIZER;
g_fOnceCB1 = false;
int rc = RTOnce(&Once1, Once1CB, (void *)1);
if (rc != VINF_SUCCESS)
RTPrintf("tstOnce: ERROR - Once1, 1 failed, rc=%Rrc\n", rc);
g_fOnceCB1 = false;
rc = RTOnce(&Once1, Once1CB, (void *)1);
if (rc != VINF_SUCCESS)
RTPrintf("tstOnce: ERROR - Once1, 2 failed, rc=%Rrc\n", rc);
/*
* Throw a bunch of threads up against a init once thing.
*/
RTPrintf("tstOnce: TESTING - bunch of threads...\n");
/* create the semaphore they'll be waiting on. */
rc = RTSemEventMultiCreate(&g_hEventMulti);
if (RT_FAILURE(rc))
{
RTPrintf("tstOnce: FATAL ERROR - RTSemEventMultiCreate returned %Rrc\n", rc);
return 1;
}
/* create the threads */
RTTHREAD aThreads[32];
for (unsigned i = 0; i < RT_ELEMENTS(aThreads); i++)
{
char szName[16];
RTStrPrintf(szName, sizeof(szName), "ONCE2-%d\n", i);
rc = RTThreadCreate(&aThreads[i], Once2Thread, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, szName);
if (RT_FAILURE(rc))
{
RTPrintf("tstOnce: ERROR - failed to create thread #%d\n", i);
g_cErrors++;
}
}
/* kick them off and yield */
rc = RTSemEventMultiSignal(g_hEventMulti);
if (RT_FAILURE(rc))
{
RTPrintf("tstOnce: FATAL ERROR - RTSemEventMultiSignal returned %Rrc\n", rc);
return 1;
}
RTThreadYield();
/* wait for all of them to finish up, 30 seconds each. */
for (unsigned i = 0; i < RT_ELEMENTS(aThreads); i++)
if (aThreads[i] != NIL_RTTHREAD)
{
int rc2;
rc = RTThreadWait(aThreads[i], 30*1000, &rc2);
if (RT_FAILURE(rc))
{
RTPrintf("tstOnce: ERROR - RTThreadWait on thread #%u returned %Rrc\n", i, rc);
g_cErrors++;
}
else if (RT_FAILURE(rc2))
{
RTPrintf("tstOnce: ERROR - Thread #%u returned %Rrc\n", i, rc2);
g_cErrors++;
}
}
/*
* Summary.
*/
if (!g_cErrors)
RTPrintf("tstOnce: SUCCESS\n");
else
RTPrintf("tstOnce: FAILURE - %d errors\n", g_cErrors);
return !!g_cErrors;
}
int main()
{
unsigned cErrors = 0;
RTR3InitExeNoArguments(0);
/*
* Basic property setting and simple matching.
*/
USBFILTER Flt1;
USBFilterInit(&Flt1, USBFILTERTYPE_CAPTURE);
/* numbers */
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_VENDOR_ID, 0x1111, true));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PRODUCT_ID, 0x2222, true));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_DEVICE, 0, true));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_DEVICE_CLASS, 0, true));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_DEVICE_SUB_CLASS, 0, true));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_DEVICE_PROTOCOL, 0xff, true));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 1, true));
TST_CHECK_RC(USBFilterSetIgnore(&Flt1, USBFILTERIDX_BUS));
TST_CHECK_RC(USBFilterSetPresentOnly(&Flt1, USBFILTERIDX_BUS));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 1, true));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 1, false));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PORT, 1, true));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PORT, 1, false));
TST_CHECK_RC(USBFilterSetIgnore(&Flt1, USBFILTERIDX_PORT));
/* strings */
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, "foobar", true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, "foobar", true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, "barbar", true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, "vendor", true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, "product", true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, "serial", true, false ));
/* cloning */
USBFILTER Dev;
USBFilterClone(&Dev, &Flt1);
TST_CHECK_EXPR(USBFilterIsIdentical(&Dev, &Flt1));
TST_CHECK_EXPR(USBFilterMatch(&Dev, &Flt1));
USBFilterDelete(&Flt1);
USBFilterDelete(&Dev);
/* make a sample device */
USBFilterInit(&Dev, USBFILTERTYPE_CAPTURE);
TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_VENDOR_ID, 0x1111, true));
TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_PRODUCT_ID, 0x2222, true));
TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_DEVICE, 0, true));
TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_DEVICE_CLASS, 0, true));
TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_DEVICE_SUB_CLASS, 0, true));
TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_DEVICE_PROTOCOL, 0xff, true));
TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_BUS, 1, true));
TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_PORT, 2, true));
TST_CHECK_RC(USBFilterSetStringExact(&Dev, USBFILTERIDX_MANUFACTURER_STR, "vendor", true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Dev, USBFILTERIDX_PRODUCT_STR, "product", true, false ));
TST_CHECK_RC(USBFilterSetStringExact(&Dev, USBFILTERIDX_SERIAL_NUMBER_STR, "serial", true, false ));
/* do some basic matching tests */
USBFilterInit(&Flt1, USBFILTERTYPE_CAPTURE);
TST_CHECK_EXPR(!USBFilterHasAnySubstatialCriteria(&Flt1));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev) /* 100% ignore filter */);
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PORT, 3, true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PORT, 2, true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 2, true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 1, true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, "no match", true, false ));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, "product", true, false ));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
/* string patterns */
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "p*", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "*product", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "product*", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*t", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*uct", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*uct", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*duct", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*x", true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "*product*", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "*oduct*", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "*produc*", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "?r??u*?t", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "?r??u*?*?*?***??t", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "?r??u*?*?*?***??", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "p*d*t", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "p*x*t", true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetIgnore(&Flt1, USBFILTERIDX_PRODUCT_STR));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
/* numeric patterns */
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1111", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0X1111", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "4369", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "010421", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1111-0x1111", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "4369-4369", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "010421-010421", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1110-0x1112", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "4360-4370", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "010420-010422", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1112-0x1110", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x0-0x1f", true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0-19", true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0-017", true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x0-0xffff", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0-65535", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0-177777", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x0-0XABCD", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x0EF-0XABCD", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0X0ef-0Xabcd", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "42|1|0x1111", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "42|0x1111|1", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1111|42|1", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1112|42|1", true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "39-59|0x256-0x101f|0xfffff-0xf000|0x1000-0x2000", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x000256-0x0101f|0xf000-0xfffff|0x000008000-0x2000|39-59", true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "| | \t \t\t| 0x256 - 0x101f | 0xf000 - 0xfeff\t| 0x1000 -\t0x6000 | 1- 0512", true));
TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev));
TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "| | \t \t\t| 0x256 - 0x101f | 0xf000 - 0xfeff\t| 0x1112 -\t0x6000 | 1- 0512", true));
TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev));
USBFilterDelete(&Flt1);
/*
* string overflow
*/
struct
{
uint64_t u64Pre;
USBFILTER Flt;
uint64_t u64Post;
} sOf;
sOf.u64Pre = sOf.u64Post = UINT64_C(0x1234567887654321);
USBFilterInit(&sOf.Flt, USBFILTERTYPE_CAPTURE);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
AssertCompileMemberSize(USBFILTER, achStrTab, 256);
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString256[0], true, false ) == VERR_BUFFER_OVERFLOW);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString256[1], true, false ) == VERR_BUFFER_OVERFLOW);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString256[2], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString256[3], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
/* 0 + 1 */
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, "", true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_PRODUCT_STR, &g_szString256[2], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_PRODUCT_STR, &g_szString256[1], true, false ) == VERR_BUFFER_OVERFLOW);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
/* 0 + 2 */
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_PRODUCT_STR, &g_szString128[2], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString128[1], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
/* 3 */
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString64[0], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_PRODUCT_STR, &g_szString64[0], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_MANUFACTURER_STR, &g_szString128[4], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_MANUFACTURER_STR, &g_szString128[4], true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_MANUFACTURER_STR, &g_szString128[3], true, false ) == VERR_BUFFER_OVERFLOW);
TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321));
/*
* Check for a string replacement bug.
*/
USBFILTER Dev2;
USBFilterInit(&Dev2, USBFILTERTYPE_CAPTURE);
TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_VENDOR_ID, 0x19b6, true) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_PRODUCT_ID, 0x1024, true) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_DEVICE_REV, 0x0141, true) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_DEVICE_CLASS, 0, true) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_DEVICE_SUB_CLASS, 0, true) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_DEVICE_PROTOCOL, 0, true) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_PORT, 0x1, true) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetStringExact(&Dev2, USBFILTERIDX_MANUFACTURER_STR, "Generic", true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetStringExact(&Dev2, USBFILTERIDX_PRODUCT_STR, "Mass Storage Device", true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterSetStringExact(&Dev2, USBFILTERIDX_MANUFACTURER_STR, "YBU1PPRS", true, false ) == VINF_SUCCESS);
TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_VENDOR_ID) == 0x19b6);
TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_PRODUCT_ID) == 0x1024);
TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_DEVICE_REV) == 0x0141);
TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_DEVICE_CLASS) == 0);
TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_DEVICE_SUB_CLASS) == 0);
TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_DEVICE_PROTOCOL) == 0);
TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_PORT) == 1);
/*
* Summary.
*/
if (!cErrors)
RTPrintf(TESTCASE ": SUCCESS\n");
else
RTPrintf(TESTCASE ": FAILURE - %d errors\n", cErrors);
return !!cErrors;
}
static int mainChild(void)
{
/*
* Init.
*/
int rc = RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
if (RT_FAILURE(rc))
{
RTPrintf("tstSupSem-Zombie-Child: fatal error: RTR3InitExeNoArguments failed with rc=%Rrc\n", rc);
return 1;
}
RTTEST hTest;
rc = RTTestCreate("tstSupSem-Zombie-Child", &hTest);
if (RT_FAILURE(rc))
{
RTPrintf("tstSupSem-Zombie-Child: fatal error: RTTestCreate failed with rc=%Rrc\n", rc);
return 1;
}
g_hTest = hTest;
PSUPDRVSESSION pSession;
rc = SUPR3Init(&pSession);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3Init failed with rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
g_pSession = pSession;
/*
* A semaphore of each kind and throw a bunch of threads on them.
*/
SUPSEMEVENT hEvent = NIL_SUPSEMEVENT;
RTTESTI_CHECK_RC(rc = SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
if (RT_SUCCESS(rc))
{
SUPSEMEVENTMULTI hEventMulti = NIL_SUPSEMEVENT;
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEventMulti), VINF_SUCCESS);
if (RT_SUCCESS(rc))
{
for (uint32_t cThreads = 0; cThreads < 5; cThreads++)
{
RTTHREAD hThread;
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemSRETimed, (void *)hEvent, 0, RTTHREADTYPE_TIMER, 0 /*fFlags*/, "IntSRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemMRETimed, (void *)hEventMulti, 0, RTTHREADTYPE_TIMER, 0 /*fFlags*/, "IntMRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemSREInf, (void *)hEvent, 0, RTTHREADTYPE_TIMER, 0 /*fFlags*/, "IntSRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemMREInf, (void *)hEventMulti, 0, RTTHREADTYPE_TIMER, 0 /*fFlags*/, "IntMRE"), VINF_SUCCESS);
RTThreadSleep(2);
}
RTThreadSleep(50);
/*
* This is where the test really starts...
*/
return 0;
}
}
return RTTestSummaryAndDestroy(hTest);
}
int main()
{
RTR3InitExeNoArguments(0);
RTPrintf("tstFileLock: TESTING\n");
RTFILE File;
int rc = RTFileOpen(&File, "tstLock.tst", RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
RTPrintf("File open: rc=%Rrc\n", rc);
if (RT_FAILURE(rc))
{
if (rc != VERR_FILE_NOT_FOUND && rc != VERR_OPEN_FAILED)
{
RTPrintf("FATAL\n");
return 1;
}
rc = RTFileOpen(&File, "tstLock.tst", RTFILE_O_READWRITE | RTFILE_O_CREATE | RTFILE_O_DENY_NONE);
RTPrintf("File create: rc=%Rrc\n", rc);
if (RT_FAILURE(rc))
{
RTPrintf("FATAL\n");
return 2;
}
fRun = true;
}
/* grow file a little */
rc = RTFileSetSize(File, fRun ? 2048 : 20480);
RTPrintf("File size: rc=%Rrc\n", rc);
int buf;
/* read test. */
rc = RTFileRead(File, &buf, sizeof(buf), NULL);
RTPrintf("Read: rc=%Rrc\n", rc);
/* write test. */
rc = RTFileWrite(File, achTest1, strlen(achTest1), NULL);
RTPrintf("Write: rc=%Rrc\n", rc);
/* lock: read, non-blocking. */
rc = RTFileLock(File, RTFILE_LOCK_READ | RTFILE_LOCK_IMMEDIATELY, 0, _4G);
RTPrintf("Lock: read, non-blocking, rc=%Rrc\n", rc);
bool fl = RT_SUCCESS(rc);
/* read test. */
rc = RTFileRead(File, &buf, sizeof(buf), NULL);
RTPrintf("Read: rc=%Rrc\n", rc);
/* write test. */
rc = RTFileWrite(File, achTest2, strlen(achTest2), NULL);
RTPrintf("Write: rc=%Rrc\n", rc);
RTPrintf("Lock test will change in three seconds\n");
for (int i = 0; i < 3; i++)
{
RTThreadSleep(1000);
RTPrintf(".");
}
RTPrintf("\n");
/* change lock: write, non-blocking. */
rc = RTFileLock(File, RTFILE_LOCK_WRITE | RTFILE_LOCK_IMMEDIATELY, 0, _4G);
RTPrintf("Change lock: write, non-blocking, rc=%Rrc\n", rc);
RTPrintf("Test will unlock in three seconds\n");
for (int i = 0; i < 3; i++)
{
RTThreadSleep(1000);
RTPrintf(".");
}
RTPrintf("\n");
/* remove lock. */
if (fl)
{
fl = false;
rc = RTFileUnlock(File, 0, _4G);
RTPrintf("Unlock: rc=%Rrc\n", rc);
RTPrintf("Write test will lock in three seconds\n");
for (int i = 0; i < 3; i++)
{
RTThreadSleep(1000);
RTPrintf(".");
}
RTPrintf("\n");
}
/* lock: write, non-blocking. */
rc = RTFileLock(File, RTFILE_LOCK_WRITE | RTFILE_LOCK_IMMEDIATELY, 0, _4G);
RTPrintf("Lock: write, non-blocking, rc=%Rrc\n", rc);
fl = RT_SUCCESS(rc);
/* grow file test */
rc = RTFileSetSize(File, fRun ? 2048 : 20480);
RTPrintf("File size: rc=%Rrc\n", rc);
/* read test. */
rc = RTFileRead(File, &buf, sizeof(buf), NULL);
RTPrintf("Read: rc=%Rrc\n", rc);
/* write test. */
rc = RTFileWrite(File, achTest3, strlen(achTest3), NULL);
RTPrintf("Write: rc=%Rrc\n", rc);
RTPrintf("Continuing to next test in three seconds\n");
for (int i = 0; i < 3; i++)
{
RTThreadSleep(1000);
RTPrintf(".");
}
RTPrintf("\n");
RTFileClose(File);
RTFileDelete("tstLock.tst");
RTPrintf("tstFileLock: I've no recollection of this testcase succeeding or not, sorry.\n");
return 0;
}