int main()
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTStrVersion", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
RTTestSub(hTest, "RTStrVersionCompare");
static struct
{
const char *pszVer1;
const char *pszVer2;
int iResult;
} const aTests[] =
{
{ "", "", 0 },
{ "asdf", "", 1 },
{ "asdf234", "1.4.5", 1 },
{ "12.foo006", "12.6", 1 },
{ "1", "1", 0 },
{ "1", "100", -1},
{ "100", "1", 1 },
{ "3", "4", -1},
{ "1", "0.1", 1 },
{ "1", "0.0.0.0.10000", 1 },
{ "0100", "100", 0 },
{ "1.0.0", "1", 0 },
{ "1.0.0", "100.0.0", -1},
{ "1", "1.0.3.0", -1},
{ "1.4.5", "1.2.3", 1 },
{ "1.2.3", "1.4.5", -1},
{ "1.2.3", "4.5.6", -1},
{ "1.0.4", "1.0.3", 1 },
{ "0.1", "0.0.1", 1 },
{ "0.0.1", "0.1.1", -1},
{ "3.1.0", "3.0.14", 1 },
{ "2.0.12", "3.0.14", -1},
{ "3.1", "3.0.22", 1 },
{ "3.0.14", "3.1.0", -1},
{ "45.63", "04.560.30", 1 },
{ "45.006", "45.6", 0 },
{ "23.206", "23.06", 1 },
{ "23.2", "23.060", -1},
{ "VirtualBox-2.0.8-Beta2", "VirtualBox-2.0.8_Beta3-r12345", -1 },
{ "VirtualBox-2.2.4-Beta2", "VirtualBox-2.2.2", 1 },
{ "VirtualBox-2.2.4-Beta3", "VirtualBox-2.2.2-Beta4", 1 },
{ "VirtualBox-3.1.8-Alpha1", "VirtualBox-3.1.8-Alpha1-r61454", -1 },
{ "VirtualBox-3.1.0", "VirtualBox-3.1.2_Beta1", -1 },
{ "3.1.0_BETA-r12345", "3.1.2", -1 },
{ "3.1.0_BETA1r12345", "3.1.0", -1 },
{ "3.1.0_BETAr12345", "3.1.0", -1 },
{ "3.1.0_BETA-r12345", "3.1.0", -1 },
{ "3.1.0_BETA-r12345", "3.1.0", -1 },
{ "3.1.0_BETA-r12345", "3.1.0.0", -1 },
{ "3.1.0_BETA", "3.1.0.0", -1 },
{ "3.1.0_BETA1", "3.1.0", -1 },
{ "3.1.0_BETA-r12345", "3.1.0r12345", -1 },
{ "3.1.0_BETA1-r12345", "3.1.0_BETA-r12345", 0 },
{ "3.1.0_BETA1-r12345", "3.1.0_BETA1-r12345", 0 },
{ "3.1.0_BETA2-r12345", "3.1.0_BETA1-r12345", 1 },
{ "3.1.0_BETA2-r12345", "3.1.0_BETA999-r12345", -1 },
{ "3.1.0_BETA2", "3.1.0_ABC", -1 }, /* ABC isn't indicating a prerelease, BETA does. */
{ "3.1.0_BETA", "3.1.0_ATEB", -1 },
{ "4.0.0_ALPHAr68482", "4.0.0_ALPHAr68483", -1 },
{ "4.0.0_ALPHA1r68482", "4.0.0_ALPHAr68482", 0 },
{ "4.0.0_ALPHA-r68482", "4.0.0_ALPHAr68482", 0 },
{ "4.0.0_ALPHAr68483", "4.0.0_BETAr68783", -1 },
{ "4.0.0_ALPHAr68483", "4.0.0_BETA1r68783", -1 },
{ "4.0.0_ALPHAr68483", "4.0.0_BETA2r68783", -1 },
{ "4.0.0_ALPHAr68483", "4.0.0_BETA2r68784", -1 },
{ "4.0.6", "4.0.6_Ubuntu", -1 }, /* Without stripped guest OS string (Ubuntu). */
{ "4.0.6_Windows", "4.0.6", 1 }, /* Without stripped guest OS string (Windows). */
{ "4.1.6r74567", "4.1.6r74567", 0 },
{ "4.1.7r74567", "4.1.6r74567", 1 },
{ "4.1.5r74567", "4.1.6r74567", -1 },
{ "4.1.6r74567-ENTERPRISE", "4.1.6r74567", 1 } /* The tagged version is "newer". */
};
for (unsigned iTest = 0; iTest < RT_ELEMENTS(aTests); iTest++)
{
int iResult = RTStrVersionCompare(aTests[iTest].pszVer1, aTests[iTest].pszVer2);
if (iResult != aTests[iTest].iResult)
RTTestFailed(hTest, "#%u: '%s' <-> '%s' -> %d, expected %d",
iTest, aTests[iTest].pszVer1, aTests[iTest].pszVer2, iResult, aTests[iTest].iResult);
iResult = -RTStrVersionCompare(aTests[iTest].pszVer2, aTests[iTest].pszVer1);
if (iResult != aTests[iTest].iResult)
RTTestFailed(hTest, "#%u: '%s' <-> '%s' -> %d, expected %d [inv]",
iTest, aTests[iTest].pszVer1, aTests[iTest].pszVer2, iResult, aTests[iTest].iResult);
}
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
int main(int argc, char *argv[])
{
/*
* Init runtime.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTHeapOffset", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* Create a heap.
*/
RTTestSub(hTest, "Basics");
static uint8_t s_abMem[128*1024];
RTHEAPOFFSET Heap;
RTTESTI_CHECK_RC(rc = RTHeapOffsetInit(&Heap, &s_abMem[1], sizeof(s_abMem) - 1), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
/*
* Try allocate.
*/
static struct TstHeapOffsetOps
{
size_t cb;
unsigned uAlignment;
void *pvAlloc;
unsigned iFreeOrder;
} s_aOps[] =
{
{ 16, 0, NULL, 0 }, // 0
{ 16, 4, NULL, 1 },
{ 16, 8, NULL, 2 },
{ 16, 16, NULL, 5 },
{ 16, 32, NULL, 4 },
{ 32, 0, NULL, 3 }, // 5
{ 31, 0, NULL, 6 },
{ 1024, 0, NULL, 8 },
{ 1024, 32, NULL, 10 },
{ 1024, 32, NULL, 12 },
{ PAGE_SIZE, PAGE_SIZE, NULL, 13 }, // 10
{ 1024, 32, NULL, 9 },
{ PAGE_SIZE, 32, NULL, 11 },
{ PAGE_SIZE, PAGE_SIZE, NULL, 14 },
{ 16, 0, NULL, 15 },
{ 9, 0, NULL, 7 }, // 15
{ 16, 0, NULL, 7 },
{ 36, 0, NULL, 7 },
{ 16, 0, NULL, 7 },
{ 12344, 0, NULL, 7 },
{ 50, 0, NULL, 7 }, // 20
{ 16, 0, NULL, 7 },
};
uint32_t i;
RTHeapOffsetDump(Heap, (PFNRTHEAPOFFSETPRINTF)RTPrintf); /** @todo Add some detail info output with a signature identical to RTPrintf. */
size_t cbBefore = RTHeapOffsetGetFreeSize(Heap);
static char const s_szFill[] = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
/* allocate */
for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
{
s_aOps[i].pvAlloc = RTHeapOffsetAlloc(Heap, s_aOps[i].cb, s_aOps[i].uAlignment);
RTTESTI_CHECK_MSG(s_aOps[i].pvAlloc, ("RTHeapOffsetAlloc(%p, %#x, %#x,) -> NULL i=%d\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
if (!s_aOps[i].pvAlloc)
return RTTestSummaryAndDestroy(hTest);
memset(s_aOps[i].pvAlloc, s_szFill[i], s_aOps[i].cb);
RTTESTI_CHECK_MSG(RT_ALIGN_P(s_aOps[i].pvAlloc, (s_aOps[i].uAlignment ? s_aOps[i].uAlignment : 8)) == s_aOps[i].pvAlloc,
("RTHeapOffsetAlloc(%p, %#x, %#x,) -> %p\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
if (!s_aOps[i].pvAlloc)
return RTTestSummaryAndDestroy(hTest);
}
/* free and allocate the same node again. */
for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
{
if (!s_aOps[i].pvAlloc)
continue;
//RTPrintf("debug: i=%d pv=%#x cb=%#zx align=%#zx cbReal=%#zx\n", i, s_aOps[i].pvAlloc,
// s_aOps[i].cb, s_aOps[i].uAlignment, RTHeapOffsetSize(Heap, s_aOps[i].pvAlloc));
size_t cbBeforeSub = RTHeapOffsetGetFreeSize(Heap);
RTHeapOffsetFree(Heap, s_aOps[i].pvAlloc);
size_t cbAfterSubFree = RTHeapOffsetGetFreeSize(Heap);
void *pv;
pv = RTHeapOffsetAlloc(Heap, s_aOps[i].cb, s_aOps[i].uAlignment);
RTTESTI_CHECK_MSG(pv, ("RTHeapOffsetAlloc(%p, %#x, %#x,) -> NULL i=%d\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
if (!pv)
return RTTestSummaryAndDestroy(hTest);
//RTPrintf("debug: i=%d pv=%p cbReal=%#zx cbBeforeSub=%#zx cbAfterSubFree=%#zx cbAfterSubAlloc=%#zx \n", i, pv, RTHeapOffsetSize(Heap, pv),
// cbBeforeSub, cbAfterSubFree, RTHeapOffsetGetFreeSize(Heap));
if (pv != s_aOps[i].pvAlloc)
RTTestIPrintf(RTTESTLVL_ALWAYS, "Warning: Free+Alloc returned different address. new=%p old=%p i=%d\n", pv, s_aOps[i].pvAlloc, i);
s_aOps[i].pvAlloc = pv;
size_t cbAfterSubAlloc = RTHeapOffsetGetFreeSize(Heap);
if (cbBeforeSub != cbAfterSubAlloc)
{
RTTestIPrintf(RTTESTLVL_ALWAYS, "Warning: cbBeforeSub=%#zx cbAfterSubFree=%#zx cbAfterSubAlloc=%#zx. i=%d\n",
cbBeforeSub, cbAfterSubFree, cbAfterSubAlloc, i);
//return 1; - won't work correctly until we start creating free block instead of donating memory on alignment.
}
}
/* make a copy of the heap and the to-be-freed list. */
static uint8_t s_abMemCopy[sizeof(s_abMem)];
memcpy(s_abMemCopy, s_abMem, sizeof(s_abMem));
uintptr_t offDelta = (uintptr_t)&s_abMemCopy[0] - (uintptr_t)&s_abMem[0];
RTHEAPOFFSET hHeapCopy = (RTHEAPOFFSET)((uintptr_t)Heap + offDelta);
static struct TstHeapOffsetOps s_aOpsCopy[RT_ELEMENTS(s_aOps)];
memcpy(&s_aOpsCopy[0], &s_aOps[0], sizeof(s_aOps));
/* free it in a specific order. */
int cFreed = 0;
for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
{
unsigned j;
for (j = 0; j < RT_ELEMENTS(s_aOps); j++)
{
if ( s_aOps[j].iFreeOrder != i
|| !s_aOps[j].pvAlloc)
continue;
//RTPrintf("j=%d i=%d free=%d cb=%d pv=%p\n", j, i, RTHeapOffsetGetFreeSize(Heap), s_aOps[j].cb, s_aOps[j].pvAlloc);
RTHeapOffsetFree(Heap, s_aOps[j].pvAlloc);
s_aOps[j].pvAlloc = NULL;
cFreed++;
}
}
RTTESTI_CHECK(cFreed == RT_ELEMENTS(s_aOps));
RTTestIPrintf(RTTESTLVL_ALWAYS, "i=done free=%d\n", RTHeapOffsetGetFreeSize(Heap));
/* check that we're back at the right amount of free memory. */
size_t cbAfter = RTHeapOffsetGetFreeSize(Heap);
if (cbBefore != cbAfter)
{
RTTestIPrintf(RTTESTLVL_ALWAYS,
"Warning: Either we've split out an alignment chunk at the start, or we've got\n"
" an alloc/free accounting bug: cbBefore=%d cbAfter=%d\n", cbBefore, cbAfter);
RTHeapOffsetDump(Heap, (PFNRTHEAPOFFSETPRINTF)RTPrintf);
}
/* relocate and free the bits in heap2 now. */
RTTestSub(hTest, "Relocated Heap");
/* free it in a specific order. */
int cFreed2 = 0;
for (i = 0; i < RT_ELEMENTS(s_aOpsCopy); i++)
{
unsigned j;
for (j = 0; j < RT_ELEMENTS(s_aOpsCopy); j++)
{
if ( s_aOpsCopy[j].iFreeOrder != i
|| !s_aOpsCopy[j].pvAlloc)
continue;
//RTPrintf("j=%d i=%d free=%d cb=%d pv=%p\n", j, i, RTHeapOffsetGetFreeSize(hHeapCopy), s_aOpsCopy[j].cb, s_aOpsCopy[j].pvAlloc);
RTHeapOffsetFree(hHeapCopy, (uint8_t *)s_aOpsCopy[j].pvAlloc + offDelta);
s_aOpsCopy[j].pvAlloc = NULL;
cFreed2++;
}
}
RTTESTI_CHECK(cFreed2 == RT_ELEMENTS(s_aOpsCopy));
/* check that we're back at the right amount of free memory. */
size_t cbAfterCopy = RTHeapOffsetGetFreeSize(hHeapCopy);
RTTESTI_CHECK_MSG(cbAfterCopy == cbAfter, ("cbAfterCopy=%zu cbAfter=%zu\n", cbAfterCopy, cbAfter));
/*
* Use random allocation pattern
*/
RTTestSub(hTest, "Random Test");
RTTESTI_CHECK_RC(rc = RTHeapOffsetInit(&Heap, &s_abMem[1], sizeof(s_abMem) - 1), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
RTRAND hRand;
RTTESTI_CHECK_RC(rc = RTRandAdvCreateParkMiller(&hRand), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
#if 0
RTRandAdvSeed(hRand, 42);
#else
RTRandAdvSeed(hRand, RTTimeNanoTS());
#endif
static struct
{
size_t cb;
void *pv;
} s_aHistory[1536];
RT_ZERO(s_aHistory);
for (unsigned iTest = 0; iTest < 131072; iTest++)
{
i = RTRandAdvU32Ex(hRand, 0, RT_ELEMENTS(s_aHistory) - 1);
if (!s_aHistory[i].pv)
{
uint32_t uAlignment = 1 << RTRandAdvU32Ex(hRand, 0, 7);
s_aHistory[i].cb = RTRandAdvU32Ex(hRand, 9, 1024);
s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, uAlignment);
if (!s_aHistory[i].pv)
{
s_aHistory[i].cb = 9;
s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 0);
}
if (s_aHistory[i].pv)
memset(s_aHistory[i].pv, 0xbb, s_aHistory[i].cb);
}
else
{
RTHeapOffsetFree(Heap, s_aHistory[i].pv);
s_aHistory[i].pv = NULL;
}
if ((iTest % 7777) == 7776)
{
/* exhaust the heap */
for (i = 0; i < RT_ELEMENTS(s_aHistory) && RTHeapOffsetGetFreeSize(Heap) >= 256; i++)
if (!s_aHistory[i].pv)
{
s_aHistory[i].cb = RTRandAdvU32Ex(hRand, 256, 16384);
s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 0);
}
for (i = 0; i < RT_ELEMENTS(s_aHistory) && RTHeapOffsetGetFreeSize(Heap); i++)
{
if (!s_aHistory[i].pv)
{
s_aHistory[i].cb = 1;
s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 1);
}
if (s_aHistory[i].pv)
memset(s_aHistory[i].pv, 0x55, s_aHistory[i].cb);
}
RTTESTI_CHECK_MSG(RTHeapOffsetGetFreeSize(Heap) == 0, ("%zu\n", RTHeapOffsetGetFreeSize(Heap)));
}
else if ((iTest % 7777) == 1111)
{
/* free all */
for (i = 0; i < RT_ELEMENTS(s_aHistory); i++)
{
RTHeapOffsetFree(Heap, s_aHistory[i].pv);
s_aHistory[i].pv = NULL;
}
size_t cbAfterRand = RTHeapOffsetGetFreeSize(Heap);
RTTESTI_CHECK_MSG(cbAfterRand == cbAfter, ("cbAfterRand=%zu cbAfter=%zu\n", cbAfterRand, cbAfter));
}
}
/* free the rest. */
for (i = 0; i < RT_ELEMENTS(s_aHistory); i++)
{
RTHeapOffsetFree(Heap, s_aHistory[i].pv);
s_aHistory[i].pv = NULL;
}
/* check that we're back at the right amount of free memory. */
size_t cbAfterRand = RTHeapOffsetGetFreeSize(Heap);
RTTESTI_CHECK_MSG(cbAfterRand == cbAfter, ("cbAfterRand=%zu cbAfter=%zu\n", cbAfterRand, cbAfter));
return RTTestSummaryAndDestroy(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);
}
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);
}
int main()
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTSystemQueryOsInfo", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* Simple stuff.
*/
char szInfo[_4K];
rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "PRODUCT: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "RELEASE: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "VERSION: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "SERVICE_PACK: \"%s\", rc=%Rrc\n", szInfo, rc);
/*
* Check that unsupported stuff is terminated correctly.
*/
for (int i = RTSYSOSINFO_INVALID + 1; i < RTSYSOSINFO_END; i++)
{
memset(szInfo, ' ', sizeof(szInfo));
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, sizeof(szInfo));
if ( rc == VERR_NOT_SUPPORTED
&& szInfo[0] != '\0')
RTTestIFailed("level=%d; unterminated buffer on VERR_NOT_SUPPORTED\n", i);
else if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
RTTESTI_CHECK(RTStrEnd(szInfo, sizeof(szInfo)) != NULL);
else if (rc != VERR_NOT_SUPPORTED)
RTTestIFailed("level=%d unexpected rc=%Rrc\n", i, rc);
}
/*
* Check buffer overflow
*/
RTAssertSetQuiet(true);
RTAssertSetMayPanic(false);
for (int i = RTSYSDMISTR_INVALID + 1; i < RTSYSDMISTR_END; i++)
{
RTTESTI_CHECK_RC(RTSystemQueryDmiString((RTSYSDMISTR)i, szInfo, 0), VERR_INVALID_PARAMETER);
/* Get the length of the info and check that we get overflow errors for
everything less that it. */
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, sizeof(szInfo));
if (RT_FAILURE(rc))
continue;
size_t const cchInfo = strlen(szInfo);
for (size_t cch = 1; cch < sizeof(szInfo) && cch < cchInfo; cch++)
{
memset(szInfo, 0x7f, sizeof(szInfo));
RTTESTI_CHECK_RC(RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, cch), VERR_BUFFER_OVERFLOW);
/* check the padding. */
for (size_t off = cch; off < sizeof(szInfo); off++)
if (szInfo[off] != 0x7f)
{
RTTestIFailed("level=%d, rc=%Rrc, cch=%zu, off=%zu: Wrote too much!\n", i, rc, cch, off);
break;
}
/* check for zero terminator. */
if (!RTStrEnd(szInfo, cch))
RTTestIFailed("level=%d, rc=%Rrc, cch=%zu: Buffer not terminated!\n", i, rc, cch);
}
/* Check that the exact length works. */
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, cchInfo + 1);
if (rc != VINF_SUCCESS)
RTTestIFailed("level=%d: rc=%Rrc when specifying exactly right buffer length (%zu)\n", i, rc, cchInfo + 1);
}
return RTTestSummaryAndDestroy(hTest);
}
int main()
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTBase64", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* Series of simple tests.
*/
static const struct
{
const char *pszText;
size_t cchText;
const char *pszEnc;
size_t cchEnc;
} g_aTests[] =
{
#define TEST_ENTRY(szText, szEnc) { szText, sizeof(szText) - 1, szEnc, sizeof(szEnc) - 1 }
TEST_ENTRY("Hey", "SGV5"),
TEST_ENTRY("Base64", "QmFzZTY0"),
TEST_ENTRY("Call me Ishmael.", "Q2FsbCBtZSBJc2htYWVsLg=="),
TEST_ENTRY(
"Man is distinguished, not only by his reason, but by this singular passion "
"from other animals, which is a lust of the mind, that by a perseverance of "
"delight in the continued and indefatigable generation of knowledge, exceeds "
"the short vehemence of any carnal pleasure." /* Thomas Hobbes's Leviathan */,
"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1" MY_NL
"dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3" MY_NL
"aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFu" MY_NL
"Y2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxl" MY_NL
"IGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhl" MY_NL
"bWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4="
)
#undef TEST_ENTRY
};
for (unsigned i = 0; i < RT_ELEMENTS(g_aTests); i++)
{
RTTestSubF(hTest, "Test 1-%u", i);
tstBase64(g_aTests[i].pszText, g_aTests[i].cchText,
g_aTests[i].pszEnc, g_aTests[i].cchEnc,
1 /* fTextData */, 1 /* fNormalEnc */);
}
/*
* Try with some more junk in the encoding and different line length.
*/
RTTestSub(hTest, "Test 2");
static const char s_szText2[] =
"Man is distinguished, not only by his reason, but by this singular passion "
"from other animals, which is a lust of the mind, that by a perseverance of "
"delight in the continued and indefatigable generation of knowledge, exceeds "
"the short vehemence of any carnal pleasure."; /* Thomas Hobbes's Leviathan */
static const char s_szEnc2[] =
" TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz\r\n"
" IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg\n\r\t\t\t\v"
"dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu\n"
"\tdWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo\n\r"
" ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=\n \n \r \n \t";
tstBase64(s_szText2, sizeof(s_szText2) - 1,
s_szEnc2, sizeof(s_szEnc2) - 1,
1 /* fTextData */, 0 /* fNormalEnc */);
/*
* Test for buffer overruns.
*/
RTTestSubF(hTest, "Test 3");
static uint8_t s_abData4[32768];
for (size_t i = 0; i < sizeof(s_abData4); i++)
s_abData4[i] = i % 256;
for (size_t cbSrc = 1; cbSrc <= sizeof(s_abData4); cbSrc++)
{
char szEnc[49152];
memset(szEnc, '\0', sizeof(szEnc));
size_t cchEnc = RTBase64EncodedLength(cbSrc);
if (cchEnc >= sizeof(szEnc))
RTTestIFailed("RTBase64EncodedLength(%zu) returned %zu bytes, too big\n", cbSrc, cchEnc);
size_t cchOut = 0;
rc = RTBase64Encode(s_abData4, cbSrc, szEnc, cchEnc, &cchOut);
if (rc != VERR_BUFFER_OVERFLOW)
RTTestIFailed("RTBase64Encode(,%zu,) has no buffer overflow with too small buffer -> %Rrc\n", cbSrc, rc);
rc = RTBase64Encode(s_abData4, cbSrc, szEnc, cchEnc + 1, &cchOut);
if (RT_FAILURE(rc))
RTTestIFailed("RTBase64Encode -> %Rrc\n", rc);
if (cchOut != cchEnc)
RTTestIFailed("RTBase64EncodedLength(%zu) returned %zu bytes, expected %zu.\n",
cbSrc, cchEnc, cchOut);
if (szEnc[cchOut + 1] != '\0')
RTTestIFailed("RTBase64Encode(,%zu,) returned string which is not zero terminated\n", cbSrc);
if (strlen(szEnc) != cchOut)
RTTestIFailed("RTBase64Encode(,%zu,) returned incorrect string, length %lu\n", cbSrc, cchOut);
}
/*
* Finally, a more extensive test.
*/
RTTestSub(hTest, "Test 4");
static uint8_t s_abData3[12*256];
for (unsigned i = 0; i < 256; i++)
{
unsigned j = i*12;
s_abData3[j + 0] = i; /* */
s_abData3[j + 1] = 0xff;
s_abData3[j + 2] = i;
s_abData3[j + 3] = 0xff; /* */
s_abData3[j + 4] = i;
s_abData3[j + 5] = 0xff;
s_abData3[j + 6] = i; /* */
s_abData3[j + 7] = 0x00;
s_abData3[j + 8] = i;
s_abData3[j + 9] = 0x00; /* */
s_abData3[j + 10]= i;
s_abData3[j + 11]= 0x00;
}
static const char s_szEnc3[] =
"AP8A/wD/AAAAAAAAAf8B/wH/AQABAAEAAv8C/wL/AgACAAIAA/8D/wP/AwADAAMA" MY_NL
"BP8E/wT/BAAEAAQABf8F/wX/BQAFAAUABv8G/wb/BgAGAAYAB/8H/wf/BwAHAAcA" MY_NL
"CP8I/wj/CAAIAAgACf8J/wn/CQAJAAkACv8K/wr/CgAKAAoAC/8L/wv/CwALAAsA" MY_NL
"DP8M/wz/DAAMAAwADf8N/w3/DQANAA0ADv8O/w7/DgAOAA4AD/8P/w//DwAPAA8A" MY_NL
"EP8Q/xD/EAAQABAAEf8R/xH/EQARABEAEv8S/xL/EgASABIAE/8T/xP/EwATABMA" MY_NL
"FP8U/xT/FAAUABQAFf8V/xX/FQAVABUAFv8W/xb/FgAWABYAF/8X/xf/FwAXABcA" MY_NL
"GP8Y/xj/GAAYABgAGf8Z/xn/GQAZABkAGv8a/xr/GgAaABoAG/8b/xv/GwAbABsA" MY_NL
"HP8c/xz/HAAcABwAHf8d/x3/HQAdAB0AHv8e/x7/HgAeAB4AH/8f/x//HwAfAB8A" MY_NL
"IP8g/yD/IAAgACAAIf8h/yH/IQAhACEAIv8i/yL/IgAiACIAI/8j/yP/IwAjACMA" MY_NL
"JP8k/yT/JAAkACQAJf8l/yX/JQAlACUAJv8m/yb/JgAmACYAJ/8n/yf/JwAnACcA" MY_NL
"KP8o/yj/KAAoACgAKf8p/yn/KQApACkAKv8q/yr/KgAqACoAK/8r/yv/KwArACsA" MY_NL
"LP8s/yz/LAAsACwALf8t/y3/LQAtAC0ALv8u/y7/LgAuAC4AL/8v/y//LwAvAC8A" MY_NL
"MP8w/zD/MAAwADAAMf8x/zH/MQAxADEAMv8y/zL/MgAyADIAM/8z/zP/MwAzADMA" MY_NL
"NP80/zT/NAA0ADQANf81/zX/NQA1ADUANv82/zb/NgA2ADYAN/83/zf/NwA3ADcA" MY_NL
"OP84/zj/OAA4ADgAOf85/zn/OQA5ADkAOv86/zr/OgA6ADoAO/87/zv/OwA7ADsA" MY_NL
"PP88/zz/PAA8ADwAPf89/z3/PQA9AD0APv8+/z7/PgA+AD4AP/8//z//PwA/AD8A" MY_NL
"QP9A/0D/QABAAEAAQf9B/0H/QQBBAEEAQv9C/0L/QgBCAEIAQ/9D/0P/QwBDAEMA" MY_NL
"RP9E/0T/RABEAEQARf9F/0X/RQBFAEUARv9G/0b/RgBGAEYAR/9H/0f/RwBHAEcA" MY_NL
"SP9I/0j/SABIAEgASf9J/0n/SQBJAEkASv9K/0r/SgBKAEoAS/9L/0v/SwBLAEsA" MY_NL
"TP9M/0z/TABMAEwATf9N/03/TQBNAE0ATv9O/07/TgBOAE4AT/9P/0//TwBPAE8A" MY_NL
"UP9Q/1D/UABQAFAAUf9R/1H/UQBRAFEAUv9S/1L/UgBSAFIAU/9T/1P/UwBTAFMA" MY_NL
"VP9U/1T/VABUAFQAVf9V/1X/VQBVAFUAVv9W/1b/VgBWAFYAV/9X/1f/VwBXAFcA" MY_NL
"WP9Y/1j/WABYAFgAWf9Z/1n/WQBZAFkAWv9a/1r/WgBaAFoAW/9b/1v/WwBbAFsA" MY_NL
"XP9c/1z/XABcAFwAXf9d/13/XQBdAF0AXv9e/17/XgBeAF4AX/9f/1//XwBfAF8A" MY_NL
"YP9g/2D/YABgAGAAYf9h/2H/YQBhAGEAYv9i/2L/YgBiAGIAY/9j/2P/YwBjAGMA" MY_NL
"ZP9k/2T/ZABkAGQAZf9l/2X/ZQBlAGUAZv9m/2b/ZgBmAGYAZ/9n/2f/ZwBnAGcA" MY_NL
"aP9o/2j/aABoAGgAaf9p/2n/aQBpAGkAav9q/2r/agBqAGoAa/9r/2v/awBrAGsA" MY_NL
"bP9s/2z/bABsAGwAbf9t/23/bQBtAG0Abv9u/27/bgBuAG4Ab/9v/2//bwBvAG8A" MY_NL
"cP9w/3D/cABwAHAAcf9x/3H/cQBxAHEAcv9y/3L/cgByAHIAc/9z/3P/cwBzAHMA" MY_NL
"dP90/3T/dAB0AHQAdf91/3X/dQB1AHUAdv92/3b/dgB2AHYAd/93/3f/dwB3AHcA" MY_NL
"eP94/3j/eAB4AHgAef95/3n/eQB5AHkAev96/3r/egB6AHoAe/97/3v/ewB7AHsA" MY_NL
"fP98/3z/fAB8AHwAff99/33/fQB9AH0Afv9+/37/fgB+AH4Af/9//3//fwB/AH8A" MY_NL
"gP+A/4D/gACAAIAAgf+B/4H/gQCBAIEAgv+C/4L/ggCCAIIAg/+D/4P/gwCDAIMA" MY_NL
"hP+E/4T/hACEAIQAhf+F/4X/hQCFAIUAhv+G/4b/hgCGAIYAh/+H/4f/hwCHAIcA" MY_NL
"iP+I/4j/iACIAIgAif+J/4n/iQCJAIkAiv+K/4r/igCKAIoAi/+L/4v/iwCLAIsA" MY_NL
"jP+M/4z/jACMAIwAjf+N/43/jQCNAI0Ajv+O/47/jgCOAI4Aj/+P/4//jwCPAI8A" MY_NL
"kP+Q/5D/kACQAJAAkf+R/5H/kQCRAJEAkv+S/5L/kgCSAJIAk/+T/5P/kwCTAJMA" MY_NL
"lP+U/5T/lACUAJQAlf+V/5X/lQCVAJUAlv+W/5b/lgCWAJYAl/+X/5f/lwCXAJcA" MY_NL
"mP+Y/5j/mACYAJgAmf+Z/5n/mQCZAJkAmv+a/5r/mgCaAJoAm/+b/5v/mwCbAJsA" MY_NL
"nP+c/5z/nACcAJwAnf+d/53/nQCdAJ0Anv+e/57/ngCeAJ4An/+f/5//nwCfAJ8A" MY_NL
"oP+g/6D/oACgAKAAof+h/6H/oQChAKEAov+i/6L/ogCiAKIAo/+j/6P/owCjAKMA" MY_NL
"pP+k/6T/pACkAKQApf+l/6X/pQClAKUApv+m/6b/pgCmAKYAp/+n/6f/pwCnAKcA" MY_NL
"qP+o/6j/qACoAKgAqf+p/6n/qQCpAKkAqv+q/6r/qgCqAKoAq/+r/6v/qwCrAKsA" MY_NL
"rP+s/6z/rACsAKwArf+t/63/rQCtAK0Arv+u/67/rgCuAK4Ar/+v/6//rwCvAK8A" MY_NL
"sP+w/7D/sACwALAAsf+x/7H/sQCxALEAsv+y/7L/sgCyALIAs/+z/7P/swCzALMA" MY_NL
"tP+0/7T/tAC0ALQAtf+1/7X/tQC1ALUAtv+2/7b/tgC2ALYAt/+3/7f/twC3ALcA" MY_NL
"uP+4/7j/uAC4ALgAuf+5/7n/uQC5ALkAuv+6/7r/ugC6ALoAu/+7/7v/uwC7ALsA" MY_NL
"vP+8/7z/vAC8ALwAvf+9/73/vQC9AL0Avv++/77/vgC+AL4Av/+//7//vwC/AL8A" MY_NL
"wP/A/8D/wADAAMAAwf/B/8H/wQDBAMEAwv/C/8L/wgDCAMIAw//D/8P/wwDDAMMA" MY_NL
"xP/E/8T/xADEAMQAxf/F/8X/xQDFAMUAxv/G/8b/xgDGAMYAx//H/8f/xwDHAMcA" MY_NL
"yP/I/8j/yADIAMgAyf/J/8n/yQDJAMkAyv/K/8r/ygDKAMoAy//L/8v/ywDLAMsA" MY_NL
"zP/M/8z/zADMAMwAzf/N/83/zQDNAM0Azv/O/87/zgDOAM4Az//P/8//zwDPAM8A" MY_NL
"0P/Q/9D/0ADQANAA0f/R/9H/0QDRANEA0v/S/9L/0gDSANIA0//T/9P/0wDTANMA" MY_NL
"1P/U/9T/1ADUANQA1f/V/9X/1QDVANUA1v/W/9b/1gDWANYA1//X/9f/1wDXANcA" MY_NL
"2P/Y/9j/2ADYANgA2f/Z/9n/2QDZANkA2v/a/9r/2gDaANoA2//b/9v/2wDbANsA" MY_NL
"3P/c/9z/3ADcANwA3f/d/93/3QDdAN0A3v/e/97/3gDeAN4A3//f/9//3wDfAN8A" MY_NL
"4P/g/+D/4ADgAOAA4f/h/+H/4QDhAOEA4v/i/+L/4gDiAOIA4//j/+P/4wDjAOMA" MY_NL
"5P/k/+T/5ADkAOQA5f/l/+X/5QDlAOUA5v/m/+b/5gDmAOYA5//n/+f/5wDnAOcA" MY_NL
"6P/o/+j/6ADoAOgA6f/p/+n/6QDpAOkA6v/q/+r/6gDqAOoA6//r/+v/6wDrAOsA" MY_NL
"7P/s/+z/7ADsAOwA7f/t/+3/7QDtAO0A7v/u/+7/7gDuAO4A7//v/+//7wDvAO8A" MY_NL
"8P/w//D/8ADwAPAA8f/x//H/8QDxAPEA8v/y//L/8gDyAPIA8//z//P/8wDzAPMA" MY_NL
"9P/0//T/9AD0APQA9f/1//X/9QD1APUA9v/2//b/9gD2APYA9//3//f/9wD3APcA" MY_NL
"+P/4//j/+AD4APgA+f/5//n/+QD5APkA+v/6//r/+gD6APoA+//7//v/+wD7APsA" MY_NL
"/P/8//z//AD8APwA/f/9//3//QD9AP0A/v/+//7//gD+AP4A/////////wD/AP8A";
tstBase64(s_abData3, sizeof(s_abData3),
s_szEnc3, sizeof(s_szEnc3) - 1,
0 /* fTextData */, 0 /* fNormalEnc */);
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
int main (int argc, char **argv)
{
#ifndef VBOX
RTPrintf("tstSup: SKIPPED\n");
return 0;
#else
/*
* Init.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTR0DbgKrnlInfo", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
uint8_t *pbPage = (uint8_t *)RTTestGuardedAllocTail(hTest, PAGE_SIZE);
if (!pbPage)
{
RTTestFailed(hTest, "RTTestGuardedAllocTail failed with rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
PSUPDRVSESSION pSession;
rc = SUPR3Init(&pSession);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3Init failed with rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
char szPath[RTPATH_MAX];
rc = RTPathExecDir(szPath, sizeof(szPath));
if (RT_SUCCESS(rc))
rc = RTPathAppend(szPath, sizeof(szPath), "tstRTR0DbgKrnlInfo.r0");
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "Failed constructing .r0 filename (rc=%Rrc)", rc);
return RTTestSummaryAndDestroy(hTest);
}
void *pvImageBase;
rc = SUPR3LoadServiceModule(szPath, "tstRTR0DbgKrnlInfo",
"tstRTR0DbgKrnlInfoSrvReqHandler",
&pvImageBase);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3LoadServiceModule(%s,,,) failed with rc=%Rrc\n", szPath, rc);
return RTTestSummaryAndDestroy(hTest);
}
/* test request */
struct
{
SUPR0SERVICEREQHDR Hdr;
char szMsg[256];
} Req;
/*
* Sanity checks.
*/
RTTestSub(hTest, "Sanity");
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0DbgKrnlInfo", sizeof("tstRTR0DbgKrnlInfo") - 1,
TSTRTR0DBGKRNLINFO_SANITY_OK, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
RTTESTI_CHECK_MSG(Req.szMsg[0] == '\0', ("%s", Req.szMsg));
if (Req.szMsg[0] != '\0')
return RTTestSummaryAndDestroy(hTest);
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0DbgKrnlInfo", sizeof("tstRTR0DbgKrnlInfo") - 1,
TSTRTR0DBGKRNLINFO_SANITY_FAILURE, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
RTTESTI_CHECK_MSG(!strncmp(Req.szMsg, "!42failure42", sizeof("!42failure42") - 1), ("%s", Req.szMsg));
if (strncmp(Req.szMsg, "!42failure42", sizeof("!42failure42") - 1))
return RTTestSummaryAndDestroy(hTest);
/*
* Basic tests, bail out on failure.
*/
RTTestSub(hTest, "Basics");
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0DbgKrnlInfo", sizeof("tstRTR0DbgKrnlInfo") - 1,
TSTRTR0DBGKRNLINFO_BASIC, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
if (Req.szMsg[0] == '!')
{
RTTestIFailed("%s", &Req.szMsg[1]);
return RTTestSummaryAndDestroy(hTest);
}
if (Req.szMsg[0])
RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
/*
* Done.
*/
return RTTestSummaryAndDestroy(hTest);
#endif
}
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
{
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()
{
/*
* Init.
*/
int rc = RTTestInitAndCreate("tstDBGCParser", &g_hTest);
if (rc)
return rc;
RTTestBanner(g_hTest);
/*
* Create a DBGC instance.
*/
RTTestSub(g_hTest, "dbgcCreate");
PDBGC pDbgc;
rc = dbgcCreate(&pDbgc, &g_tstBack, 0);
if (RT_SUCCESS(rc))
{
rc = dbgcProcessInput(pDbgc, true /* fNoExecute */);
tstCompleteOutput();
if (RT_SUCCESS(rc))
{
RTTestSub(g_hTest, "basic parsing");
tstTry(pDbgc, "stop\n", VINF_SUCCESS);
tstTry(pDbgc, "format 1\n", VINF_SUCCESS);
tstTry(pDbgc, "format \n", VERR_PARSE_TOO_FEW_ARGUMENTS);
tstTry(pDbgc, "format 0 1 23 4\n", VERR_PARSE_TOO_MANY_ARGUMENTS);
tstTry(pDbgc, "sa 3 23 4 'q' \"21123123\" 'b' \n", VINF_SUCCESS);
if (RTTestErrorCount(g_hTest) == 0)
{
RTTestSub(g_hTest, "Operators");
tstNumOp(pDbgc, "1", 1);
tstNumOp(pDbgc, "1", 1);
tstNumOp(pDbgc, "1", 1);
tstNumOp(pDbgc, "+1", 1);
tstNumOp(pDbgc, "++++++1", 1);
tstNumOp(pDbgc, "-1", UINT64_MAX);
tstNumOp(pDbgc, "--1", 1);
tstNumOp(pDbgc, "---1", UINT64_MAX);
tstNumOp(pDbgc, "----1", 1);
tstNumOp(pDbgc, "~0", UINT64_MAX);
tstNumOp(pDbgc, "~1", UINT64_MAX-1);
tstNumOp(pDbgc, "~~0", 0);
tstNumOp(pDbgc, "~~1", 1);
tstNumOp(pDbgc, "!1", 0);
tstNumOp(pDbgc, "!0", 1);
tstNumOp(pDbgc, "!42", 0);
tstNumOp(pDbgc, "!!42", 1);
tstNumOp(pDbgc, "!!!42", 0);
tstNumOp(pDbgc, "!!!!42", 1);
tstNumOp(pDbgc, "1 +1", 2);
tstNumOp(pDbgc, "1 + 1", 2);
tstNumOp(pDbgc, "1+1", 2);
tstNumOp(pDbgc, "1+ 1", 2);
tstNumOp(pDbgc, "1 - 1", 0);
tstNumOp(pDbgc, "99 - 90", 9);
tstNumOp(pDbgc, "2 * 2", 4);
tstNumOp(pDbgc, "2 / 2", 1);
tstNumOp(pDbgc, "2 / 0", UINT64_MAX);
tstNumOp(pDbgc, "0i1024 / 0i4", 256);
tstNumOp(pDbgc, "1<<1", 2);
tstNumOp(pDbgc, "1<<0i32", UINT64_C(0x0000000100000000));
tstNumOp(pDbgc, "1<<0i48", UINT64_C(0x0001000000000000));
tstNumOp(pDbgc, "1<<0i63", UINT64_C(0x8000000000000000));
tstNumOp(pDbgc, "fedcba0987654321>>0i04", UINT64_C(0x0fedcba098765432));
tstNumOp(pDbgc, "fedcba0987654321>>0i32", UINT64_C(0xfedcba09));
tstNumOp(pDbgc, "fedcba0987654321>>0i48", UINT64_C(0x0000fedc));
tstNumOp(pDbgc, "0ef & 4", 4);
tstNumOp(pDbgc, "01234567891 & fff", UINT64_C(0x00000000891));
tstNumOp(pDbgc, "01234567891 & ~fff", UINT64_C(0x01234567000));
tstNumOp(pDbgc, "1 | 1", 1);
tstNumOp(pDbgc, "0 | 4", 4);
tstNumOp(pDbgc, "4 | 0", 4);
tstNumOp(pDbgc, "4 | 4", 4);
tstNumOp(pDbgc, "1 | 4 | 2", 7);
tstNumOp(pDbgc, "1 ^ 1", 0);
tstNumOp(pDbgc, "1 ^ 0", 1);
tstNumOp(pDbgc, "0 ^ 1", 1);
tstNumOp(pDbgc, "3 ^ 1", 2);
tstNumOp(pDbgc, "7 ^ 3", 4);
tstNumOp(pDbgc, "7 || 3", 1);
tstNumOp(pDbgc, "1 || 0", 1);
tstNumOp(pDbgc, "0 || 1", 1);
tstNumOp(pDbgc, "0 || 0", 0);
tstNumOp(pDbgc, "0 && 0", 0);
tstNumOp(pDbgc, "1 && 0", 0);
tstNumOp(pDbgc, "0 && 1", 0);
tstNumOp(pDbgc, "1 && 1", 1);
tstNumOp(pDbgc, "4 && 1", 1);
}
if (RTTestErrorCount(g_hTest) == 0)
{
RTTestSub(g_hTest, "Odd cases");
tstTry(pDbgc, "r @rax\n", VINF_SUCCESS);
tstTry(pDbgc, "r @eax\n", VINF_SUCCESS);
tstTry(pDbgc, "r @ah\n", VINF_SUCCESS);
}
}
dbgcDestroy(pDbgc);
}
/*
* Summary
*/
return RTTestSummaryAndDestroy(g_hTest);
}
int main()
{
char szPath[RTPATH_MAX];
/*
* Init RT+Test.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTPath", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
RTTestSub(hTest, "Environment");
#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
RTTESTI_CHECK(RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS);
# if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
# else
RTTestIFailed("#if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS");
# endif
RTTESTI_CHECK(strcmp(RTPATH_SLASH_STR, "\\") == 0);
RTTESTI_CHECK(RTPATH_SLASH == '\\');
RTTESTI_CHECK(RTPATH_IS_SEP('/'));
RTTESTI_CHECK(RTPATH_IS_SEP('\\'));
RTTESTI_CHECK(RTPATH_IS_SEP(':'));
#else
RTTESTI_CHECK(RTPATH_STYLE == RTPATH_STR_F_STYLE_UNIX);
# if RTPATH_STYLE == RTPATH_STR_F_STYLE_UNIX
# else
RTTestIFailed("#if RTPATH_STYLE == RTPATH_STR_F_STYLE_UNIX");
# endif
RTTESTI_CHECK(strcmp(RTPATH_SLASH_STR, "/") == 0);
RTTESTI_CHECK(RTPATH_SLASH == '/');
RTTESTI_CHECK(RTPATH_IS_SEP('/'));
RTTESTI_CHECK(!RTPATH_IS_SEP('\\'));
RTTESTI_CHECK(!RTPATH_IS_SEP(':'));
#endif
/*
* RTPathExecDir, RTPathUserHome and RTProcGetExecutablePath.
*/
RTTestSub(hTest, "RTPathExecDir");
RTTESTI_CHECK_RC(rc = RTPathExecDir(szPath, sizeof(szPath)), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTestIPrintf(RTTESTLVL_INFO, "ExecDir={%s}\n", szPath);
RTTestSub(hTest, "RTProcGetExecutablePath");
if (RTProcGetExecutablePath(szPath, sizeof(szPath)) == szPath)
RTTestIPrintf(RTTESTLVL_INFO, "ExecutableName={%s}\n", szPath);
else
RTTestIFailed("RTProcGetExecutablePath -> NULL");
RTTestSub(hTest, "RTPathUserHome");
RTTESTI_CHECK_RC(rc = RTPathUserHome(szPath, sizeof(szPath)), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTestIPrintf(RTTESTLVL_INFO, "UserHome={%s}\n", szPath);
RTTestSub(hTest, "RTPathUserDocuments");
RTTESTI_CHECK_RC(rc = RTPathUserDocuments(szPath, sizeof(szPath)), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTestIPrintf(RTTESTLVL_INFO, "UserDocuments={%s}\n", szPath);
RTTestSub(hTest, "RTPathTemp");
RTTESTI_CHECK_RC(rc = RTPathTemp(szPath, sizeof(szPath)), VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTestIPrintf(RTTESTLVL_INFO, "PathTemp={%s}\n", szPath);
size_t cch = strlen(szPath);
RTTESTI_CHECK_RC(RTPathTemp(szPath, cch), VERR_BUFFER_OVERFLOW);
RTTESTI_CHECK_RC(RTPathTemp(szPath, cch+1), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathTemp(szPath, cch+2), VINF_SUCCESS);
/*
* RTPathAbsEx
*/
RTTestSub(hTest, "RTPathAbsEx");
static const struct
{
const char *pcszInputBase;
const char *pcszInputPath;
int rc;
const char *pcszOutput;
}
s_aRTPathAbsExTests[] =
{
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
{ NULL, "", VERR_INVALID_PARAMETER, NULL },
{ NULL, ".", VINF_SUCCESS, "%p" },
{ NULL, "\\", VINF_SUCCESS, "%d\\" },
{ NULL, "\\..", VINF_SUCCESS, "%d\\" },
{ NULL, "/absolute/..", VINF_SUCCESS, "%d\\" },
{ NULL, "/absolute\\\\../..", VINF_SUCCESS, "%d\\" },
{ NULL, "/absolute//../path\\", VINF_SUCCESS, "%d\\path" },
{ NULL, "/absolute/../../path", VINF_SUCCESS, "%d\\path" },
{ NULL, "relative/../dir\\.\\.\\.\\file.txt", VINF_SUCCESS, "%p\\dir\\file.txt" },
{ NULL, "\\data\\", VINF_SUCCESS, "%d\\data" },
{ "relative_base/dir\\", "\\from_root", VINF_SUCCESS, "%d\\from_root" },
{ "relative_base/dir/", "relative_also", VINF_SUCCESS, "%p\\relative_base\\dir\\relative_also" },
#else
{ NULL, "", VERR_INVALID_PARAMETER, NULL },
{ NULL, ".", VINF_SUCCESS, "%p" },
{ NULL, "/", VINF_SUCCESS, "/" },
{ NULL, "/..", VINF_SUCCESS, "/" },
{ NULL, "/absolute/..", VINF_SUCCESS, "/" },
{ NULL, "/absolute\\\\../..", VINF_SUCCESS, "/" },
{ NULL, "/absolute//../path/", VINF_SUCCESS, "/path" },
{ NULL, "/absolute/../../path", VINF_SUCCESS, "/path" },
{ NULL, "relative/../dir/./././file.txt", VINF_SUCCESS, "%p/dir/file.txt" },
{ NULL, "relative/../dir\\.\\.\\.\\file.txt", VINF_SUCCESS, "%p/dir\\.\\.\\.\\file.txt" }, /* linux-specific */
{ NULL, "/data/", VINF_SUCCESS, "/data" },
{ "relative_base/dir/", "/from_root", VINF_SUCCESS, "/from_root" },
{ "relative_base/dir/", "relative_also", VINF_SUCCESS, "%p/relative_base/dir/relative_also" },
#endif
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
{ NULL, "C:\\", VINF_SUCCESS, "C:\\" },
{ "C:\\", "..", VINF_SUCCESS, "C:\\" },
{ "C:\\temp", "..", VINF_SUCCESS, "C:\\" },
{ "C:\\VirtualBox/Machines", "..\\VirtualBox.xml", VINF_SUCCESS, "C:\\VirtualBox\\VirtualBox.xml" },
{ "C:\\MustDie", "\\from_root/dir/..", VINF_SUCCESS, "C:\\from_root" },
{ "C:\\temp", "D:\\data", VINF_SUCCESS, "D:\\data" },
{ NULL, "\\\\server\\..\\share", VINF_SUCCESS, "\\\\server\\..\\share" /* kind of strange */ },
{ NULL, "\\\\server/", VINF_SUCCESS, "\\\\server\\" },
{ NULL, "\\\\", VINF_SUCCESS, "\\\\" },
{ NULL, "\\\\\\something", VINF_SUCCESS, "\\\\\\something" /* kind of strange */ },
{ "\\\\server\\share_as_base", "/from_root", VINF_SUCCESS, "\\\\server\\from_root" },
{ "\\\\just_server", "/from_root", VINF_SUCCESS, "\\\\just_server\\from_root" },
{ "\\\\server\\share_as_base", "relative\\data", VINF_SUCCESS, "\\\\server\\share_as_base\\relative\\data" },
{ "base", "\\\\?\\UNC\\relative/edwef/..", VINF_SUCCESS, "\\\\?\\UNC\\relative" },
{ "\\\\?\\UNC\\base", "/from_root", VERR_INVALID_NAME, NULL },
#else
{ "/temp", "..", VINF_SUCCESS, "/" },
{ "/VirtualBox/Machines", "../VirtualBox.xml", VINF_SUCCESS, "/VirtualBox/VirtualBox.xml" },
{ "/MustDie", "/from_root/dir/..", VINF_SUCCESS, "/from_root" },
{ "\\temp", "\\data", VINF_SUCCESS, "%p/\\temp/\\data" },
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aRTPathAbsExTests); ++ i)
{
rc = RTPathAbsEx(s_aRTPathAbsExTests[i].pcszInputBase,
s_aRTPathAbsExTests[i].pcszInputPath,
szPath, sizeof(szPath));
if (rc != s_aRTPathAbsExTests[i].rc)
{
RTTestIFailed("unexpected result code!\n"
" input base: '%s'\n"
" input path: '%s'\n"
" output: '%s'\n"
" rc: %Rrc\n"
" expected rc: %Rrc",
s_aRTPathAbsExTests[i].pcszInputBase,
s_aRTPathAbsExTests[i].pcszInputPath,
szPath, rc,
s_aRTPathAbsExTests[i].rc);
continue;
}
char szTmp[RTPATH_MAX];
char *pszExpected = NULL;
if (s_aRTPathAbsExTests[i].pcszOutput != NULL)
{
if (s_aRTPathAbsExTests[i].pcszOutput[0] == '%')
{
RTTESTI_CHECK_RC(rc = RTPathGetCurrent(szTmp, sizeof(szTmp)), VINF_SUCCESS);
if (RT_FAILURE(rc))
break;
pszExpected = szTmp;
if (s_aRTPathAbsExTests[i].pcszOutput[1] == 'p')
{
cch = strlen(szTmp);
if (cch + strlen(s_aRTPathAbsExTests[i].pcszOutput) - 2 <= sizeof(szTmp))
strcpy(szTmp + cch, s_aRTPathAbsExTests[i].pcszOutput + 2);
}
#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
else if (s_aRTPathAbsExTests[i].pcszOutput[1] == 'd')
{
if (2 + strlen(s_aRTPathAbsExTests[i].pcszOutput) - 2 <= sizeof(szTmp))
strcpy(szTmp + 2, s_aRTPathAbsExTests[i].pcszOutput + 2);
}
#endif
}
else
{
strcpy(szTmp, s_aRTPathAbsExTests[i].pcszOutput);
pszExpected = szTmp;
}
if (strcmp(szPath, pszExpected))
{
RTTestIFailed("Unexpected result\n"
" input base: '%s'\n"
" input path: '%s'\n"
" output: '%s'\n"
" expected: '%s'",
s_aRTPathAbsExTests[i].pcszInputBase,
s_aRTPathAbsExTests[i].pcszInputPath,
szPath,
s_aRTPathAbsExTests[i].pcszOutput);
}
}
}
/*
* RTPathStripFilename
*/
RTTestSub(hTest, "RTPathStripFilename");
static const char *s_apszStripFilenameTests[] =
{
"/usr/include///", "/usr/include//",
"/usr/include/", "/usr/include",
"/usr/include", "/usr",
"/usr", "/",
"usr", ".",
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
"c:/windows", "c:/",
"c:/", "c:/",
"D:", "D:",
"C:\\OS2\\DLLS", "C:\\OS2",
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_apszStripFilenameTests); i += 2)
{
const char *pszInput = s_apszStripFilenameTests[i];
const char *pszExpect = s_apszStripFilenameTests[i + 1];
strcpy(szPath, pszInput);
RTPathStripFilename(szPath);
if (strcmp(szPath, pszExpect))
{
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, szPath, pszExpect);
}
}
/*
* RTPathAppend.
*/
RTTestSub(hTest, "RTPathAppend");
static const char *s_apszAppendTests[] =
{
/* base append result */
"/", "", "/",
"", "/", "/",
"/", "/", "/",
"/x", "", "/x",
"/x", "/", "/x/",
"/", "x", "/x",
"dir", "file", "dir/file",
"dir", "/file", "dir/file",
"dir", "//file", "dir/file",
"dir", "///file", "dir/file",
"dir/", "/file", "dir/file",
"dir/", "//file", "dir/file",
"dir/", "///file", "dir/file",
"dir//", "file", "dir/file",
"dir//", "/file", "dir/file",
"dir//", "//file", "dir/file",
"dir///", "///file", "dir/file",
"/bin/testcase", "foo.r0", "/bin/testcase/foo.r0",
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
"/", "\\", "/",
"\\", "/", "\\",
"\\\\srv\\shr", "dir//", "\\\\srv\\shr/dir//",
"\\\\srv\\shr", "dir//file", "\\\\srv\\shr/dir//file",
"\\\\srv\\shr", "//dir//", "\\\\srv\\shr/dir//",
"\\\\srv\\shr", "/\\dir//", "\\\\srv\\shr\\dir//",
"\\\\", "not-srv/not-shr/file", "\\not-srv/not-shr/file",
"C:", "autoexec.bat", "C:autoexec.bat",
"C:", "/autoexec.bat", "C:/autoexec.bat",
"C:", "\\autoexec.bat", "C:\\autoexec.bat",
"C:\\", "/autoexec.bat", "C:\\autoexec.bat",
"C:\\\\", "autoexec.bat", "C:\\autoexec.bat",
"E:\\bin\\testcase", "foo.r0", "E:\\bin\\testcase/foo.r0",
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_apszAppendTests); i += 3)
{
const char *pszInput = s_apszAppendTests[i];
const char *pszAppend = s_apszAppendTests[i + 1];
const char *pszExpect = s_apszAppendTests[i + 2];
strcpy(szPath, pszInput);
RTTESTI_CHECK_RC(rc = RTPathAppend(szPath, sizeof(szPath), pszAppend), VINF_SUCCESS);
if (RT_FAILURE(rc))
continue;
if (strcmp(szPath, pszExpect))
{
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" append: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, pszAppend, szPath, pszExpect);
}
else
{
size_t const cchResult = strlen(szPath);
strcpy(szPath, pszInput);
RTTESTI_CHECK_RC(rc = RTPathAppend(szPath, cchResult + 2, pszAppend), VINF_SUCCESS);
RTTESTI_CHECK(RT_FAILURE(rc) || !strcmp(szPath, pszExpect));
strcpy(szPath, pszInput);
RTTESTI_CHECK_RC(rc = RTPathAppend(szPath, cchResult + 1, pszAppend), VINF_SUCCESS);
RTTESTI_CHECK(RT_FAILURE(rc) || !strcmp(szPath, pszExpect));
if (strlen(pszInput) < cchResult)
{
strcpy(szPath, pszInput);
RTTESTI_CHECK_RC(RTPathAppend(szPath, cchResult, pszAppend), VERR_BUFFER_OVERFLOW);
}
}
}
/*
* RTPathJoin - reuse the append tests.
*/
RTTestSub(hTest, "RTPathJoin");
for (unsigned i = 0; i < RT_ELEMENTS(s_apszAppendTests); i += 3)
{
const char *pszInput = s_apszAppendTests[i];
const char *pszAppend = s_apszAppendTests[i + 1];
const char *pszExpect = s_apszAppendTests[i + 2];
memset(szPath, 'a', sizeof(szPath));
szPath[sizeof(szPath) - 1] = '\0';
RTTESTI_CHECK_RC(rc = RTPathJoin(szPath, sizeof(szPath), pszInput, pszAppend), VINF_SUCCESS);
if (RT_FAILURE(rc))
continue;
if (strcmp(szPath, pszExpect))
{
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" append: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, pszAppend, szPath, pszExpect);
}
else
{
size_t const cchResult = strlen(szPath);
memset(szPath, 'a', sizeof(szPath));
szPath[sizeof(szPath) - 1] = '\0';
RTTESTI_CHECK_RC(rc = RTPathJoin(szPath, cchResult + 2, pszInput, pszAppend), VINF_SUCCESS);
RTTESTI_CHECK(RT_FAILURE(rc) || !strcmp(szPath, pszExpect));
memset(szPath, 'a', sizeof(szPath));
szPath[sizeof(szPath) - 1] = '\0';
RTTESTI_CHECK_RC(rc = RTPathJoin(szPath, cchResult + 1, pszInput, pszAppend), VINF_SUCCESS);
RTTESTI_CHECK(RT_FAILURE(rc) || !strcmp(szPath, pszExpect));
RTTESTI_CHECK_RC(rc = RTPathJoin(szPath, cchResult, pszInput, pszAppend), VERR_BUFFER_OVERFLOW);
}
}
/*
* RTPathJoinA - reuse the append tests.
*/
RTTestSub(hTest, "RTPathJoinA");
for (unsigned i = 0; i < RT_ELEMENTS(s_apszAppendTests); i += 3)
{
const char *pszInput = s_apszAppendTests[i];
const char *pszAppend = s_apszAppendTests[i + 1];
const char *pszExpect = s_apszAppendTests[i + 2];
char *pszPathDst;
RTTESTI_CHECK(pszPathDst = RTPathJoinA(pszInput, pszAppend));
if (!pszPathDst)
continue;
if (strcmp(pszPathDst, pszExpect))
{
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" append: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, pszAppend, pszPathDst, pszExpect);
}
RTStrFree(pszPathDst);
}
/*
* RTPathStripTrailingSlash
*/
static const char *s_apszStripTrailingSlash[] =
{
/* input result */
"/", "/",
"//", "/",
"////////////////////", "/",
"/tmp", "/tmp",
"/tmp////////////////", "/tmp",
"tmp", "tmp",
"tmp////////////////", "tmp",
"./", ".",
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
"////////////////////", "/",
"D:", "D:",
"D:/", "D:/",
"D:\\", "D:\\",
"D:\\/\\", "D:\\",
"D:/\\/\\", "D:/",
"C:/Temp", "C:/Temp",
"C:/Temp/", "C:/Temp",
"C:/Temp\\/", "C:/Temp",
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_apszStripTrailingSlash); i += 2)
{
const char *pszInput = s_apszStripTrailingSlash[i];
const char *pszExpect = s_apszStripTrailingSlash[i + 1];
strcpy(szPath, pszInput);
cch = RTPathStripTrailingSlash(szPath);
if (strcmp(szPath, pszExpect))
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, szPath, pszExpect);
else
RTTESTI_CHECK(cch == strlen(szPath));
}
/*
* RTPathCountComponents
*/
RTTestSub(hTest, "RTPathCountComponents");
RTTESTI_CHECK(RTPathCountComponents("") == 0);
RTTESTI_CHECK(RTPathCountComponents("/") == 1);
RTTESTI_CHECK(RTPathCountComponents("//") == 1);
RTTESTI_CHECK(RTPathCountComponents("//////////////") == 1);
RTTESTI_CHECK(RTPathCountComponents("//////////////bin") == 2);
RTTESTI_CHECK(RTPathCountComponents("//////////////bin/") == 2);
RTTESTI_CHECK(RTPathCountComponents("//////////////bin/////") == 2);
RTTESTI_CHECK(RTPathCountComponents("..") == 1);
RTTESTI_CHECK(RTPathCountComponents("../") == 1);
RTTESTI_CHECK(RTPathCountComponents("../..") == 2);
RTTESTI_CHECK(RTPathCountComponents("../../") == 2);
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
RTTESTI_CHECK(RTPathCountComponents("d:") == 1);
RTTESTI_CHECK(RTPathCountComponents("d:/") == 1);
RTTESTI_CHECK(RTPathCountComponents("d:/\\") == 1);
RTTESTI_CHECK(RTPathCountComponents("d:\\") == 1);
RTTESTI_CHECK(RTPathCountComponents("c:\\config.sys") == 2);
RTTESTI_CHECK(RTPathCountComponents("c:\\windows") == 2);
RTTESTI_CHECK(RTPathCountComponents("c:\\windows\\") == 2);
RTTESTI_CHECK(RTPathCountComponents("c:\\windows\\system32") == 3);
RTTESTI_CHECK(RTPathCountComponents("//./C$") == 1);
RTTESTI_CHECK(RTPathCountComponents("\\\\.\\C$") == 1);
RTTESTI_CHECK(RTPathCountComponents("/\\.\\C$") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share/") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share\\") == 1);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share\\x") == 2);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share\\x\\y") == 3);
RTTESTI_CHECK(RTPathCountComponents("//myserver/share\\x\\y\\") == 3);
#endif
/*
* RTPathCopyComponents
*/
struct
{
const char *pszSrc;
size_t cComponents;
const char *pszResult;
} s_aCopyComponents[] =
{
{ "", 0, "" },
{ "", 5, "" },
{ "/", 0, "" },
{ "/", 1, "/" },
{ "/", 2, "/" },
{ "/usr/bin/sed", 0, "" },
{ "/usr/bin/sed", 1, "/" },
{ "/usr/bin/sed", 2, "/usr/" },
{ "/usr/bin/sed", 3, "/usr/bin/" },
{ "/usr/bin/sed", 4, "/usr/bin/sed" },
{ "/usr/bin/sed", 5, "/usr/bin/sed" },
{ "/usr/bin/sed", 6, "/usr/bin/sed" },
{ "/usr///bin/sed", 2, "/usr///" },
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aCopyComponents); i++)
{
const char *pszInput = s_aCopyComponents[i].pszSrc;
size_t cComponents = s_aCopyComponents[i].cComponents;
const char *pszResult = s_aCopyComponents[i].pszResult;
memset(szPath, 'a', sizeof(szPath));
rc = RTPathCopyComponents(szPath, sizeof(szPath), pszInput, cComponents);
RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
if (RT_SUCCESS(rc) && strcmp(szPath, pszResult))
RTTestIFailed("Unexpected result\n"
" input: '%s' cComponents=%u\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, cComponents, szPath, pszResult);
else if (RT_SUCCESS(rc))
{
RTTESTI_CHECK_RC(RTPathCopyComponents(szPath, strlen(pszResult) + 1, pszInput, cComponents), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathCopyComponents(szPath, strlen(pszResult), pszInput, cComponents), VERR_BUFFER_OVERFLOW);
}
}
/*
* RTPathStripSuffix
*/
RTTestSub(hTest, "RTPathStripSuffix");
struct
{
const char *pszSrc;
const char *pszResult;
} s_aStripExt[] =
{
{ "filename.ext", "filename" },
{ "filename.ext1.ext2.ext3", "filename.ext1.ext2" },
{ "filename..ext", "filename." },
{ "filename.ext.", "filename.ext." },
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aStripExt); i++)
{
const char *pszInput = s_aStripExt[i].pszSrc;
const char *pszResult = s_aStripExt[i].pszResult;
strcpy(szPath, pszInput);
RTPathStripSuffix(szPath);
if (strcmp(szPath, pszResult))
RTTestIFailed("Unexpected result\n"
" input: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszInput, szPath, pszResult);
}
/*
* RTPathCalcRelative
*/
RTTestSub(hTest, "RTPathCalcRelative");
struct
{
const char *pszFrom;
const char *pszTo;
int rc;
const char *pszExpected;
} s_aRelPath[] =
{
{ "/home/test.ext", "/home/test2.ext", VINF_SUCCESS, "test2.ext"},
{ "/dir/test.ext", "/dir/dir2/test2.ext", VINF_SUCCESS, "dir2/test2.ext"},
{ "/dir/dir2/test.ext", "/dir/test2.ext", VINF_SUCCESS, ".." RTPATH_SLASH_STR "test2.ext"},
{ "/dir/dir2/test.ext", "/dir/dir3/test2.ext", VINF_SUCCESS, ".." RTPATH_SLASH_STR "dir3/test2.ext"},
#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
{ "\\\\server\\share\\test.ext", "\\\\server\\share2\\test2.ext", VERR_NOT_SUPPORTED, ""},
{ "c:\\dir\\test.ext", "f:\\dir\\test.ext", VERR_NOT_SUPPORTED, ""}
#endif
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aRelPath); i++)
{
const char *pszFrom = s_aRelPath[i].pszFrom;
const char *pszTo = s_aRelPath[i].pszTo;
rc = RTPathCalcRelative(szPath, sizeof(szPath), pszFrom, pszTo);
if (rc != s_aRelPath[i].rc)
RTTestIFailed("Unexpected return code\n"
" got: %Rrc\n"
"expected: %Rrc",
rc, s_aRelPath[i].rc);
else if ( RT_SUCCESS(rc)
&& strcmp(szPath, s_aRelPath[i].pszExpected))
RTTestIFailed("Unexpected result\n"
" from: '%s'\n"
" to: '%s'\n"
" output: '%s'\n"
"expected: '%s'",
pszFrom, pszTo, szPath, s_aRelPath[i].pszExpected);
}
testParserAndSplitter(hTest);
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
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()
{
/*
* Init the runtime and stuff.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTBitOperations", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
int i;
int j;
int k;
/*
* Tests
*/
struct TestMap
{
uint32_t au32[4];
};
#if 0
struct TestMap sTest;
struct TestMap *p = &sTest;
#else
struct TestMap *p = (struct TestMap *)RTTestGuardedAllocTail(hTest, sizeof(*p));
#endif
#define DUMP() RTTestPrintf(hTest, RTTESTLVL_INFO, "au32={%08x,%08x,%08x,%08x}", p->au32[0], p->au32[1], p->au32[2], p->au32[3])
#define CHECK(expr) do { if (!(expr)) { RTTestFailed(hTest, "line %d: %s", __LINE__, #expr); DUMP(); } CHECK_GUARD(s); } while (0)
#define CHECK_BIT(expr, b1) do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d: %s", __LINE__, b1, #expr); } CHECK_GUARD(s); } while (0)
#define CHECK_BIT2(expr, b1, b2) do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d b2=%d: %s", __LINE__, b1, b2, #expr); } CHECK_GUARD(s); } while (0)
#define CHECK_BIT3(expr, b1, b2, b3) do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d b2=%d b3=%d: %s", __LINE__, b1, b2, b3, #expr); } CHECK_GUARD(s); } while (0)
#define GUARD_MAP(p) do { } while (0)
#define CHECK_GUARD(p) do { } while (0)
#define MAP_CLEAR(p) do { RT_ZERO(*(p)); GUARD_MAP(p); } while (0)
#define MAP_SET(p) do { memset(p, 0xff, sizeof(*(p))); GUARD_MAP(p); } while (0)
/* self check. */
MAP_CLEAR(p);
CHECK_GUARD(p);
/* set */
MAP_CLEAR(p);
ASMBitSet(&p->au32[0], 0);
ASMBitSet(&p->au32[0], 31);
ASMBitSet(&p->au32[0], 65);
CHECK(p->au32[0] == 0x80000001U);
CHECK(p->au32[2] == 0x00000002U);
CHECK(ASMBitTestAndSet(&p->au32[0], 0) && p->au32[0] == 0x80000001U);
CHECK(!ASMBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x80010001U);
CHECK(ASMBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x80010001U);
CHECK(!ASMBitTestAndSet(&p->au32[0], 80) && p->au32[2] == 0x00010002U);
MAP_CLEAR(p);
ASMAtomicBitSet(&p->au32[0], 0);
ASMAtomicBitSet(&p->au32[0], 30);
ASMAtomicBitSet(&p->au32[0], 64);
CHECK(p->au32[0] == 0x40000001U);
CHECK(p->au32[2] == 0x00000001U);
CHECK(ASMAtomicBitTestAndSet(&p->au32[0], 0) && p->au32[0] == 0x40000001U);
CHECK(!ASMAtomicBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x40010001U);
CHECK(ASMAtomicBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x40010001U);
CHECK(!ASMAtomicBitTestAndSet(&p->au32[0], 80) && p->au32[2] == 0x00010001U);
/* clear */
MAP_SET(p);
ASMBitClear(&p->au32[0], 0);
ASMBitClear(&p->au32[0], 31);
ASMBitClear(&p->au32[0], 65);
CHECK(p->au32[0] == ~0x80000001U);
CHECK(p->au32[2] == ~0x00000002U);
CHECK(!ASMBitTestAndClear(&p->au32[0], 0) && p->au32[0] == ~0x80000001U);
CHECK(ASMBitTestAndClear(&p->au32[0], 16) && p->au32[0] == ~0x80010001U);
CHECK(!ASMBitTestAndClear(&p->au32[0], 16) && p->au32[0] == ~0x80010001U);
CHECK(ASMBitTestAndClear(&p->au32[0], 80) && p->au32[2] == ~0x00010002U);
MAP_SET(p);
ASMAtomicBitClear(&p->au32[0], 0);
ASMAtomicBitClear(&p->au32[0], 30);
ASMAtomicBitClear(&p->au32[0], 64);
CHECK(p->au32[0] == ~0x40000001U);
CHECK(p->au32[2] == ~0x00000001U);
CHECK(!ASMAtomicBitTestAndClear(&p->au32[0], 0) && p->au32[0] == ~0x40000001U);
CHECK(ASMAtomicBitTestAndClear(&p->au32[0], 16) && p->au32[0] == ~0x40010001U);
CHECK(!ASMAtomicBitTestAndClear(&p->au32[0], 16) && p->au32[0] == ~0x40010001U);
CHECK(ASMAtomicBitTestAndClear(&p->au32[0], 80) && p->au32[2] == ~0x00010001U);
/* toggle */
MAP_SET(p);
ASMBitToggle(&p->au32[0], 0);
ASMBitToggle(&p->au32[0], 31);
ASMBitToggle(&p->au32[0], 65);
ASMBitToggle(&p->au32[0], 47);
ASMBitToggle(&p->au32[0], 47);
CHECK(p->au32[0] == ~0x80000001U);
CHECK(p->au32[2] == ~0x00000002U);
CHECK(!ASMBitTestAndToggle(&p->au32[0], 0) && p->au32[0] == ~0x80000000U);
CHECK(ASMBitTestAndToggle(&p->au32[0], 0) && p->au32[0] == ~0x80000001U);
CHECK(ASMBitTestAndToggle(&p->au32[0], 16) && p->au32[0] == ~0x80010001U);
CHECK(!ASMBitTestAndToggle(&p->au32[0], 16) && p->au32[0] == ~0x80000001U);
CHECK(ASMBitTestAndToggle(&p->au32[0], 80) && p->au32[2] == ~0x00010002U);
MAP_SET(p);
ASMAtomicBitToggle(&p->au32[0], 0);
ASMAtomicBitToggle(&p->au32[0], 30);
ASMAtomicBitToggle(&p->au32[0], 64);
ASMAtomicBitToggle(&p->au32[0], 47);
ASMAtomicBitToggle(&p->au32[0], 47);
CHECK(p->au32[0] == ~0x40000001U);
CHECK(p->au32[2] == ~0x00000001U);
CHECK(!ASMAtomicBitTestAndToggle(&p->au32[0], 0) && p->au32[0] == ~0x40000000U);
CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 0) && p->au32[0] == ~0x40000001U);
CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 16) && p->au32[0] == ~0x40010001U);
CHECK(!ASMAtomicBitTestAndToggle(&p->au32[0], 16) && p->au32[0] == ~0x40000001U);
CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 80) && p->au32[2] == ~0x00010001U);
/* test bit. */
for (i = 0; i < 128; i++)
{
MAP_SET(p);
CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
ASMBitToggle(&p->au32[0], i);
CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
CHECK_BIT(!ASMBitTestAndToggle(&p->au32[0], i), i);
CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
CHECK_BIT(ASMBitTestAndToggle(&p->au32[0], i), i);
CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
MAP_SET(p);
CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
ASMAtomicBitToggle(&p->au32[0], i);
CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
CHECK_BIT(!ASMAtomicBitTestAndToggle(&p->au32[0], i), i);
CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
CHECK_BIT(ASMAtomicBitTestAndToggle(&p->au32[0], i), i);
CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
}
/* bit searching */
MAP_SET(p);
CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == -1);
CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
ASMBitClear(&p->au32[0], 1);
CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 1);
CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
MAP_SET(p);
ASMBitClear(&p->au32[0], 95);
CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 95);
CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
MAP_SET(p);
ASMBitClear(&p->au32[0], 127);
CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 127);
CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 0) == 1);
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 1) == 2);
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 2) == 3);
MAP_SET(p);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 0) == -1);
ASMBitClear(&p->au32[0], 32);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 32) == -1);
ASMBitClear(&p->au32[0], 88);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 57) == 88);
MAP_SET(p);
ASMBitClear(&p->au32[0], 31);
ASMBitClear(&p->au32[0], 57);
ASMBitClear(&p->au32[0], 88);
ASMBitClear(&p->au32[0], 101);
ASMBitClear(&p->au32[0], 126);
ASMBitClear(&p->au32[0], 127);
CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 31);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 31) == 57);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 57) == 88);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 88) == 101);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 101) == 126);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 126) == 127);
CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 127) == -1);
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 29) == 30);
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 30) == 32);
MAP_CLEAR(p);
for (i = 1; i < 128; i++)
CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, i - 1) == i, i);
for (i = 0; i < 128; i++)
{
MAP_SET(p);
ASMBitClear(&p->au32[0], i);
CHECK_BIT(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == i, i);
for (j = 0; j < i; j++)
CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, j) == i, i);
for (j = i; j < 128; j++)
CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, j) == -1, i);
}
/* clear range. */
MAP_SET(p);
ASMBitClearRange(&p->au32, 0, 128);
CHECK(!p->au32[0] && !p->au32[1] && !p->au32[2] && !p->au32[3]);
for (i = 0; i < 128; i++)
{
for (j = i + 1; j <= 128; j++)
{
MAP_SET(p);
ASMBitClearRange(&p->au32, i, j);
for (k = 0; k < i; k++)
CHECK_BIT3(ASMBitTest(&p->au32[0], k), i, j, k);
for (k = i; k < j; k++)
CHECK_BIT3(!ASMBitTest(&p->au32[0], k), i, j, k);
for (k = j; k < 128; k++)
CHECK_BIT3(ASMBitTest(&p->au32[0], k), i, j, k);
}
}
/* searching for set bits. */
MAP_CLEAR(p);
CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == -1);
ASMBitSet(&p->au32[0], 65);
CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 65);
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 65) == -1);
for (i = 0; i < 65; i++)
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 65);
for (i = 65; i < 128; i++)
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == -1);
ASMBitSet(&p->au32[0], 17);
CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 17);
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 17) == 65);
for (i = 0; i < 16; i++)
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 17);
for (i = 17; i < 65; i++)
CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 65);
MAP_SET(p);
for (i = 1; i < 128; i++)
CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i - 1) == i, i);
for (i = 0; i < 128; i++)
{
MAP_CLEAR(p);
ASMBitSet(&p->au32[0], i);
CHECK_BIT(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == i, i);
for (j = 0; j < i; j++)
CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, j) == i, i);
for (j = i; j < 128; j++)
CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, j) == -1, i);
}
CHECK(ASMBitLastSetU32(0) == 0);
CHECK(ASMBitLastSetU32(1) == 1);
CHECK(ASMBitLastSetU32(0x80000000) == 32);
CHECK(ASMBitLastSetU32(0xffffffff) == 32);
CHECK(ASMBitLastSetU32(RT_BIT(23) | RT_BIT(11)) == 24);
for (i = 0; i < 32; i++)
CHECK(ASMBitLastSetU32(1 << i) == (unsigned)i + 1);
CHECK(ASMBitFirstSetU32(0) == 0);
CHECK(ASMBitFirstSetU32(1) == 1);
CHECK(ASMBitFirstSetU32(0x80000000) == 32);
CHECK(ASMBitFirstSetU32(0xffffffff) == 1);
CHECK(ASMBitFirstSetU32(RT_BIT(23) | RT_BIT(11)) == 12);
for (i = 0; i < 32; i++)
CHECK(ASMBitFirstSetU32(1 << i) == (unsigned)i + 1);
/*
* Special tests.
*/
test2(hTest);
/*
* 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: 33540 $\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)
{
/*
* Deal with child processes first.
*/
if (argc == 2 && !strcmp(argv[1], "--testcase-child-1"))
return tstRTCreateProcEx1Child();
if (argc == 2 && !strcmp(argv[1], "--testcase-child-2"))
return tstRTCreateProcEx2Child();
if (argc == 2 && !strcmp(argv[1], "--testcase-child-3"))
return tstRTCreateProcEx3Child();
if (argc >= 5 && !strcmp(argv[1], "--testcase-child-4"))
return tstRTCreateProcEx4Child(argc, argv);
if (argc >= 2 && !strcmp(argv[1], "--testcase-child-5"))
return tstRTCreateProcEx5Child(argc, argv);
if (argc >= 2 && !strcmp(argv[1], "--testcase-child-6"))
return tstRTCreateProcEx6Child(argc, argv);
/*
* Main process.
*/
const char *pszAsUser = NULL;
const char *pszPassword = NULL;
if (argc != 1)
{
if (argc != 4 || strcmp(argv[1], "--as-user"))
return 99;
pszAsUser = argv[2];
pszPassword = argv[3];
}
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTProcCreateEx", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* Init globals.
*/
if (!RTProcGetExecutablePath(g_szExecName, sizeof(g_szExecName)))
RTStrCopy(g_szExecName, sizeof(g_szExecName), argv[0]);
RTTESTI_CHECK_RC(RTEnvClone(&g_hEnvInitial, RTENV_DEFAULT), VINF_SUCCESS);
/*
* The tests.
*/
tstRTCreateProcEx1(pszAsUser, pszPassword);
tstRTCreateProcEx2(pszAsUser, pszPassword);
tstRTCreateProcEx3(pszAsUser, pszPassword);
tstRTCreateProcEx4(pszAsUser, pszPassword);
if (pszAsUser)
tstRTCreateProcEx5(pszAsUser, pszPassword);
tstRTCreateProcEx6(pszAsUser, pszPassword);
/** @todo Cover files, ++ */
RTEnvDestroy(g_hEnvInitial);
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
int main()
{
/* How many integer test items should be created. */
static const size_t s_cTestCount = 1000;
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitAndCreate("tstIprtList", &hTest);
if (rcExit)
return rcExit;
RTTestBanner(hTest);
/* Some host info. */
RTTestIPrintf(RTTESTLVL_ALWAYS, "sizeof(void*)=%d", sizeof(void*));
/*
* The tests.
*/
/*
* Native types.
*/
uint8_t au8TestInts[s_cTestCount];
for (size_t i = 0; i < RT_ELEMENTS(au8TestInts); ++i)
au8TestInts[i] = (uint8_t)RTRandU32Ex(1, UINT8_MAX);
test1<RTCList, uint8_t, uint8_t, uint8_t>("ST: Native type", au8TestInts, RT_ELEMENTS(au8TestInts));
test1<RTCMTList, uint8_t, uint8_t, uint8_t>("MT: Native type", au8TestInts, RT_ELEMENTS(au8TestInts));
uint16_t au16TestInts[s_cTestCount];
for (size_t i = 0; i < RT_ELEMENTS(au16TestInts); ++i)
au16TestInts[i] = (uint16_t)RTRandU32Ex(1, UINT16_MAX);
test1<RTCList, uint16_t, uint16_t, uint16_t>("ST: Native type", au16TestInts, RT_ELEMENTS(au16TestInts));
test1<RTCMTList, uint16_t, uint16_t, uint16_t>("MT: Native type", au16TestInts, RT_ELEMENTS(au16TestInts));
uint32_t au32TestInts[s_cTestCount];
for (size_t i = 0; i < RT_ELEMENTS(au32TestInts); ++i)
au32TestInts[i] = RTRandU32Ex(1, UINT32_MAX);
test1<RTCList, uint32_t, uint32_t, uint32_t>("ST: Native type", au32TestInts, RT_ELEMENTS(au32TestInts));
test1<RTCMTList, uint32_t, uint32_t, uint32_t>("MT: Native type", au32TestInts, RT_ELEMENTS(au32TestInts));
/*
* Specialized type.
*/
uint64_t au64TestInts[s_cTestCount];
for (size_t i = 0; i < RT_ELEMENTS(au64TestInts); ++i)
au64TestInts[i] = RTRandU64Ex(1, UINT64_MAX);
test1<RTCList, uint64_t, uint64_t, uint64_t>("ST: Specialized type", au64TestInts, RT_ELEMENTS(au64TestInts));
test1<RTCMTList, uint64_t, uint64_t, uint64_t>("MT: Specialized type", au64TestInts, RT_ELEMENTS(au64TestInts));
/*
* Big size type (translate to internal pointer list).
*/
test1<RTCList, RTCString, RTCString *, const char *>("ST: Class type", g_apszTestStrings, RT_ELEMENTS(g_apszTestStrings));
test1<RTCMTList, RTCString, RTCString *, const char *>("MT: Class type", g_apszTestStrings, RT_ELEMENTS(g_apszTestStrings));
/*
* Multi-threading test.
*/
test2();
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
int main()
{
/*
* Set up the test environment.
*/
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitAndCreate("tstX86-1", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(hTest);
g_pbEfPage = (uint8_t *)RTTestGuardedAllocTail(hTest, PAGE_SIZE);
RTTESTI_CHECK(g_pbEfPage != NULL);
g_pbEfExecPage = (uint8_t *)RTMemExecAlloc(PAGE_SIZE*2);
RTTESTI_CHECK(g_pbEfExecPage != NULL);
RTTESTI_CHECK(!((uintptr_t)g_pbEfExecPage & PAGE_OFFSET_MASK));
RTTESTI_CHECK_RC(RTMemProtect(g_pbEfExecPage + PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_NONE), VINF_SUCCESS);
#ifdef USE_SIGNAL
static int const s_aiSigs[] = { SIGBUS, SIGSEGV, SIGFPE, SIGILL };
for (unsigned i = 0; i < RT_ELEMENTS(s_aiSigs); i++)
{
struct sigaction SigAct;
RTTESTI_CHECK_BREAK(sigaction(s_aiSigs[i], NULL, &SigAct) == 0);
SigAct.sa_sigaction = sigHandler;
SigAct.sa_flags |= SA_SIGINFO;
RTTESTI_CHECK(sigaction(s_aiSigs[i], &SigAct, NULL) == 0);
}
#else
/** @todo implement me. */
#endif
if (!RTTestErrorCount(hTest))
{
/*
* Do the testing.
*/
int32_t rc;
#if 0
RTTestSub(hTest, "Misc 1");
rc = x861_Test1();
if (rc != 0)
RTTestFailed(hTest, "x861_Test1 -> %d", rc);
RTTestSub(hTest, "Prefixes and groups");
rc = x861_Test2();
if (rc != 0)
RTTestFailed(hTest, "x861_Test2 -> %d", rc);
RTTestSub(hTest, "fxsave / fxrstor and #PFs");
rc = x861_Test3();
if (rc != 0)
RTTestFailed(hTest, "x861_Test3 -> %d", rc);
RTTestSub(hTest, "Multibyte NOPs");
rc = x861_Test4();
if (rc != 0)
RTTestFailed(hTest, "x861_Test4 -> %d", rc);
//#endif
RTTestSub(hTest, "Odd encodings and odd ends");
rc = x861_Test5();
if (rc != 0)
RTTestFailed(hTest, "x861_Test5 -> %d", rc);
//#if 0
RTTestSub(hTest, "Odd floating point encodings");
rc = x861_Test6();
if (rc != 0)
RTTestFailed(hTest, "x861_Test5 -> %d", rc);
RTTestSub(hTest, "Floating point exceptions ++");
rc = x861_Test7();
if (rc != 0)
RTTestFailed(hTest, "x861_Test6 -> %d", rc);
#endif
rc = x861_TestFPUInstr1();
if (rc != 0)
RTTestFailed(hTest, "x861_TestFPUInstr1 -> %d", rc);
}
return RTTestSummaryAndDestroy(hTest);
}
