/**
* Check hash and memory performance.
*/
static void tst2(void)
{
RTTestISub("Hash performance");
/*
* Generate test strings using a specific pseudo random generator.
*/
size_t cbStrings = 0;
char *apszTests[8192];
RTRAND hRand;
RTTESTI_CHECK_RC_RETV(RTRandAdvCreateParkMiller(&hRand), VINF_SUCCESS);
for (uint32_t i = 0; i < 8192; i++)
{
char szBuf[8192];
uint32_t cch = RTRandAdvU32Ex(hRand, 3, sizeof(szBuf) - 1);
RTRandAdvBytes(hRand, szBuf, cch);
szBuf[cch] = '\0';
for (uint32_t off = 0; off < cch; off++)
{
uint8_t b = szBuf[off];
b &= 0x7f;
if (!b || b == 0x7f)
b = ' ';
else if (RTLocCIsCntrl(b) && b != '\n' && b != '\r' && b != '\t')
b += 0x30;
szBuf[off] = b;
}
apszTests[i] = (char *)RTMemDup(szBuf, cch + 1);
RTTESTI_CHECK_RETV(apszTests[i] != NULL);
cbStrings += cch + 1;
}
RTRandAdvDestroy(hRand);
RTTestIValue("Average string", cbStrings / RT_ELEMENTS(apszTests), RTTESTUNIT_BYTES);
/*
* Test new insertion first time around.
*/
RTSTRCACHE hStrCache;
RTTESTI_CHECK_RC_RETV(RTStrCacheCreate(&hStrCache, "hash performance"), VINF_SUCCESS);
uint64_t nsTsStart = RTTimeNanoTS();
for (uint32_t i = 0; i < RT_ELEMENTS(apszTests); i++)
RTTESTI_CHECK_RETV(RTStrCacheEnter(hStrCache, apszTests[i]) != NULL);
uint64_t cNsElapsed = RTTimeNanoTS() - nsTsStart;
RTTestIValue("First insert", cNsElapsed / RT_ELEMENTS(apszTests), RTTESTUNIT_NS_PER_CALL);
/*
* Insert existing strings.
*/
nsTsStart = RTTimeNanoTS();
for (uint32_t i = 0; i < 8192; i++)
RTTESTI_CHECK(RTStrCacheEnter(hStrCache, apszTests[i]) != NULL);
cNsElapsed = RTTimeNanoTS() - nsTsStart;
RTTestIValue("Duplicate insert", cNsElapsed / RT_ELEMENTS(apszTests), RTTESTUNIT_NS_PER_CALL);
tstShowStats(hStrCache);
RTTESTI_CHECK_RC(RTStrCacheDestroy(hStrCache), VINF_SUCCESS);
}
int main(int argc, char *argv[])
{
RTR3InitExe(argc, &argv, 0);
int rc;
VDSNAPTEST Test;
RTPrintf("tstVDSnap: TESTING...\n");
rc = RTRandAdvCreateParkMiller(&g_hRand);
if (RT_FAILURE(rc))
{
RTPrintf("tstVDSnap: Creating RNG failed rc=%Rrc\n", rc);
return 1;
}
RTRandAdvSeed(g_hRand, 0x12345678);
Test.pcszBackend = "vmdk";
Test.pcszBaseImage = "tstVDSnapBase.vmdk";
Test.pcszDiffSuff = "vmdk";
Test.cIterations = 30;
Test.cbTestPattern = 10 * _1M;
Test.cDiskSegsMin = 10;
Test.cDiskSegsMax = 50;
Test.cDiffsMinBeforeMerge = 5;
Test.uCreateDiffChance = 50; /* % */
Test.uChangeSegChance = 50; /* % */
Test.uAllocatedBlocks = 50; /* 50% allocated */
Test.fForward = true;
tstVDOpenCreateWriteMerge(&Test);
/* Same test with backwards merge */
Test.fForward = false;
tstVDOpenCreateWriteMerge(&Test);
rc = VDShutdown();
if (RT_FAILURE(rc))
{
RTPrintf("tstVDSnap: unloading backends failed! rc=%Rrc\n", rc);
g_cErrors++;
}
/*
* Summary
*/
if (!g_cErrors)
RTPrintf("tstVDSnap: SUCCESS\n");
else
RTPrintf("tstVDSnap: FAILURE - %d errors\n", g_cErrors);
RTRandAdvDestroy(g_hRand);
return !!g_cErrors;
}
/**
* Test automatic cleanup upon destruction.
*/
static void tst3(void)
{
RTTestISub("Destroy non-empty pool");
/*
* Nothing freed.
*/
RTMEMPOOL hMemPool;
RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 3a"), VINF_SUCCESS);
RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 10));
RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 20));
RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 40));
RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 80));
RTTESTI_CHECK_RC_RETV(RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
/*
* Pseudo random freeing to test list maintenance.
*/
RTRAND hRand;
RTTESTI_CHECK_RC_OK_RETV(RTRandAdvCreateParkMiller(&hRand));
for (uint32_t i = 0; i < 10; i++)
{
RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 3b"), VINF_SUCCESS);
void *apvHistory[256];
RT_ZERO(apvHistory);
uint32_t cBlocks = 0;
uint32_t j;
for (j = 0; j < RT_ELEMENTS(apvHistory) - i * 7; j++)
{
RTTESTI_CHECK_RETV(apvHistory[j] = RTMemPoolAlloc(hMemPool, j));
memset(apvHistory[j], 'a', j);
cBlocks++;
if (RTRandAdvU32Ex(hRand, 0, 4) == 4)
{
uint32_t iFree = RTRandAdvU32Ex(hRand, 0, j);
cBlocks -= apvHistory[iFree] != NULL;
RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, apvHistory[iFree]) == 0);
apvHistory[iFree] = NULL;
}
}
RTTESTI_CHECK_RC_RETV(RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
RTTestIPrintf(RTTESTLVL_INFO, "cBlocks=%u j=%u\n", cBlocks, j);
}
RTRandAdvDestroy(hRand);
}
static DECLCALLBACK(int) Test4Thread(RTTHREAD ThreadSelf, void *pvUser)
{
/* Use randomization to get a little more variation of the sync pattern.
We use a pseudo random generator here so that we don't end up testing
the speed of the /dev/urandom implementation, but rather the read-write
semaphores. */
int rc;
RTRAND hRand;
RTTEST_CHECK_RC_OK_RET(g_hTest, rc = RTRandAdvCreateParkMiller(&hRand), rc);
RTTEST_CHECK_RC_OK_RET(g_hTest, rc = RTRandAdvSeed(hRand, (uintptr_t)ThreadSelf), rc);
unsigned c100 = RTRandAdvU32Ex(hRand, 0, 99);
uint64_t *pcItr = (uint64_t *)pvUser;
bool fWrite;
for (;;)
{
unsigned readrec = RTRandAdvU32Ex(hRand, 0, 3);
unsigned writerec = RTRandAdvU32Ex(hRand, 0, 3);
/* Don't overdo recursion testing. */
if (readrec > 1)
readrec--;
if (writerec > 1)
writerec--;
fWrite = (c100 < g_uWritePercent);
if (fWrite)
{
for (unsigned i = 0; i <= writerec; i++)
{
rc = RTCritSectRwEnterExcl(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Write recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
if (RT_FAILURE(rc))
break;
if (ASMAtomicIncU32(&g_cConcurrentWriters) != 1)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after write locking it",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
if (g_cConcurrentReaders != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s after write locking it",
g_cConcurrentReaders, RTThreadSelfName());
break;
}
}
else
{
rc = RTCritSectRwEnterShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read locking on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
break;
}
ASMAtomicIncU32(&g_cConcurrentReaders);
if (g_cConcurrentWriters != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after read locking it",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
}
for (unsigned i = 0; i < readrec; i++)
{
rc = RTCritSectRwEnterShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
if (RT_FAILURE(rc))
break;
/*
* Check for fairness: The values of the threads should not differ too much
*/
(*pcItr)++;
/*
* Check for correctness: Give other threads a chance. If the implementation is
* correct, no other thread will be able to enter this lock now.
*/
if (g_fYield)
RTThreadYield();
for (unsigned i = 0; i < readrec; i++)
{
rc = RTCritSectRwLeaveShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
if (RT_FAILURE(rc))
break;
if (fWrite)
{
if (ASMAtomicDecU32(&g_cConcurrentWriters) != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before write release",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
if (g_cConcurrentReaders != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s before write release",
g_cConcurrentReaders, RTThreadSelfName());
break;
}
for (unsigned i = 0; i <= writerec; i++)
{
rc = RTCritSectRwLeaveExcl(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Write release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
break;
}
}
}
else
{
if (g_cConcurrentWriters != 0)
{
RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before read release",
g_cConcurrentWriters, RTThreadSelfName());
break;
}
ASMAtomicDecU32(&g_cConcurrentReaders);
rc = RTCritSectRwLeaveShared(&g_CritSectRw);
if (RT_FAILURE(rc))
{
RTTestFailed(g_hTest, "Read release on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
break;
}
}
if (g_fTerminate)
break;
c100++;
c100 %= 100;
}
if (!g_fQuiet)
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Thread %s exited with %lld\n", RTThreadSelfName(), *pcItr);
RTRandAdvDestroy(hRand);
return VINF_SUCCESS;
}
static int tstRandAdv(RTRAND hRand)
{
/*
* 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 RTRandAdvU32Ex(,%#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 = RTRandAdvU32Ex(hRand, 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 RTRandAdvU64Ex(,%#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 = RTRandAdvU64Ex(hRand, 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 RTRandAdvS32Ex(,%#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 = RTRandAdvS32Ex(hRand, 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 RTRandAdvS64Ex(,%#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 = RTRandAdvS64Ex(hRand, 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
/*
* Test saving and restoring the state.
*/
RTPrintf("tstRand: TESTING RTRandAdvSave/RestoreSave\n");
char szState[256];
size_t cbState = sizeof(szState);
int rc = RTRandAdvSaveState(hRand, szState, &cbState);
if (rc != VERR_NOT_SUPPORTED)
{
CHECK_EXPR_MSG(rc == VINF_SUCCESS, ("RTRandAdvSaveState(%p,,256) -> %Rrc (%d)\n", (uintptr_t)hRand, rc, rc));
uint32_t const u32A1 = RTRandAdvU32(hRand);
uint32_t const u32B1 = RTRandAdvU32(hRand);
RTPrintf("tstRand: state:\"%s\" A=%RX32 B=%RX32\n", szState, u32A1, u32B1);
rc = RTRandAdvRestoreState(hRand, szState);
CHECK_EXPR_MSG(rc == VINF_SUCCESS, ("RTRandAdvRestoreState(%p,\"%s\") -> %Rrc (%d)\n", (uintptr_t)hRand, szState, rc, rc));
uint32_t const u32A2 = RTRandAdvU32(hRand);
uint32_t const u32B2 = RTRandAdvU32(hRand);
CHECK_EXPR_MSG(u32A1 == u32A2, ("u32A1=%RX32 u32A2=%RX32\n", u32A1, u32A2));
CHECK_EXPR_MSG(u32B1 == u32B2, ("u32B1=%RX32 u32B2=%RX32\n", u32B1, u32B2));
}
else
{
szState[0] = '\0';
rc = RTRandAdvRestoreState(hRand, szState);
CHECK_EXPR_MSG(rc == VERR_NOT_SUPPORTED, ("RTRandAdvRestoreState(%p,\"\") -> %Rrc (%d)\n", (uintptr_t)hRand, rc, rc));
}
/*
* Destroy it.
*/
rc = RTRandAdvDestroy(hRand);
CHECK_EXPR_MSG(rc == VINF_SUCCESS, ("RTRandAdvDestroy(%p) -> %Rrc (%d)\n", (uintptr_t)hRand, rc, rc));
return 0;
}
