/** * The parent main routine. * @param argv0 The executable name (or whatever). */ static int mainParent(const char *argv0) { /* * Init. */ RTTEST hTest; int rc = RTTestInitAndCreate("tstSupSem-Zombie", &hTest); if (rc) return rc; RTTestBanner(hTest); /* * Spin of the child process which may or may not turn into a zombie */ for (uint32_t iPass = 0; iPass < 32; iPass++) { RTTestSubF(hTest, "Pass %u", iPass); RTPROCESS hProcess; const char *apszArgs[3] = { argv0, "--child", NULL }; RTTESTI_CHECK_RC_OK(rc = RTProcCreate(argv0, apszArgs, RTENV_DEFAULT, 0 /*fFlags*/, &hProcess)); if (RT_SUCCESS(rc)) { /* * Wait for 60 seconds then give up. */ RTPROCSTATUS Status; uint64_t StartTS = RTTimeMilliTS(); for (;;) { rc = RTProcWait(hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &Status); if (RT_SUCCESS(rc)) break; uint64_t cElapsed = RTTimeMilliTS() - StartTS; if (cElapsed > 60*1000) break; RTThreadSleep(cElapsed < 60 ? 30 : cElapsed < 200 ? 10 : 100); } RTTESTI_CHECK_RC_OK(rc); if ( RT_SUCCESS(rc) && ( Status.enmReason != RTPROCEXITREASON_NORMAL || Status.iStatus != 0)) { RTTestIFailed("child %d (%#x) reason %d\n", Status.iStatus, Status.iStatus, Status.enmReason); rc = VERR_PERMISSION_DENIED; } } /* one zombie process is enough. */ if (RT_FAILURE(rc)) break; } return RTTestSummaryAndDestroy(hTest); }
/** * Time constrained test with and unlimited N threads. */ static void tst3(uint32_t cThreads, uint32_t cbObject, int iMethod, uint32_t cSecs) { RTTestISubF("Benchmark - %u threads, %u bytes, %u secs, %s", cThreads, cbObject, cSecs, iMethod == 0 ? "RTMemCache" : "RTMemAlloc"); /* * Create a cache with unlimited space, a start semaphore and line up * the threads. */ RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&g_hMemCache, cbObject, 0 /*cbAlignment*/, UINT32_MAX, NULL, NULL, NULL, 0 /*fFlags*/), VINF_SUCCESS); RTSEMEVENTMULTI hEvt; RTTESTI_CHECK_RC_OK_RETV(RTSemEventMultiCreate(&hEvt)); TST3THREAD aThreads[64]; RTTESTI_CHECK_RETV(cThreads < RT_ELEMENTS(aThreads)); ASMAtomicWriteBool(&g_fTst3Stop, false); for (uint32_t i = 0; i < cThreads; i++) { aThreads[i].hThread = NIL_RTTHREAD; aThreads[i].cIterations = 0; aThreads[i].fUseCache = iMethod == 0; aThreads[i].cbObject = cbObject; aThreads[i].hEvt = hEvt; RTTESTI_CHECK_RC_OK_RETV(RTThreadCreateF(&aThreads[i].hThread, tst3Thread, &aThreads[i], 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tst3-%u", i)); } /* * Start the race. */ RTTimeNanoTS(); /* warmup */ uint64_t uStartTS = RTTimeNanoTS(); RTTESTI_CHECK_RC_OK_RETV(RTSemEventMultiSignal(hEvt)); RTThreadSleep(cSecs * 1000); ASMAtomicWriteBool(&g_fTst3Stop, true); for (uint32_t i = 0; i < cThreads; i++) RTTESTI_CHECK_RC_OK_RETV(RTThreadWait(aThreads[i].hThread, 60*1000, NULL)); uint64_t cElapsedNS = RTTimeNanoTS() - uStartTS; /* * Sum up the counts. */ uint64_t cIterations = 0; for (uint32_t i = 0; i < cThreads; i++) cIterations += aThreads[i].cIterations; RTTestIPrintf(RTTESTLVL_ALWAYS, "%'8u iterations per second, %'llu ns on avg\n", (unsigned)((long double)cIterations * 1000000000.0 / cElapsedNS), cElapsedNS / cIterations); /* clean up */ RTTESTI_CHECK_RC(RTMemCacheDestroy(g_hMemCache), VINF_SUCCESS); RTTESTI_CHECK_RC_OK(RTSemEventMultiDestroy(hEvt)); }
/** * Close the interfaces. * * @param pThis The test instance. */ static void tstCloseInterfaces(PTSTSTATE pThis) { int rc; RTTESTI_CHECK_RC_OK(rc = IntNetR0IfClose(pThis->hIf0, g_pSession)); if (RT_SUCCESS(rc)) { pThis->hIf0 = INTNET_HANDLE_INVALID; pThis->pBuf0 = NULL; } RTTESTI_CHECK_RC_OK(rc = IntNetR0IfClose(pThis->hIf1, g_pSession)); if (RT_SUCCESS(rc)) { pThis->hIf1 = INTNET_HANDLE_INVALID; pThis->pBuf1 = NULL; } /* The network should be dead now. */ RTTESTI_CHECK(IntNetR0GetNetworkCount() == 0); }
/** sub test */ static void tst4Sub(uint32_t cThreads) { RTTestISubF("Serialization - %u threads", cThreads); RTMEMPOOL hMemPool; RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 2a"), VINF_SUCCESS); g_hMemPool4 = hMemPool; PRTTHREAD pahThreads = (PRTTHREAD)RTMemPoolAlloc(hMemPool, cThreads * sizeof(RTTHREAD)); RTTESTI_CHECK(pahThreads); if (pahThreads) { /* start them. */ for (uint32_t i = 0; i < cThreads; i++) { int rc = RTThreadCreateF(&pahThreads[i], tst4Thread, (void *)(uintptr_t)i, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tst4-%u/%u", i, cThreads); RTTESTI_CHECK_RC_OK(rc); if (RT_FAILURE(rc)) pahThreads[i] = NIL_RTTHREAD; } RTThreadYield(); /* kick them off. */ for (uint32_t i = 0; i < cThreads; i++) if (pahThreads[i] != NIL_RTTHREAD) RTTESTI_CHECK_RC_OK(RTThreadUserSignal(pahThreads[i])); /* wait for them. */ for (uint32_t i = 0; i < cThreads; i++) if (pahThreads[i] != NIL_RTTHREAD) { int rc = RTThreadWait(pahThreads[i], 2*60*1000, NULL); RTTESTI_CHECK_RC_OK(rc); } } RTTESTI_CHECK_RC(RTMemPoolDestroy(hMemPool), VINF_SUCCESS); }
static void testFile(const char *pszFilename) { size_t cbSrcActually = 0; void *pvSrc; size_t cbSrc; int rc = RTFileReadAll(pszFilename, &pvSrc, &cbSrc); RTTESTI_CHECK_RC_OK_RETV(rc); size_t cbDstActually = 0; size_t cbDst = RT_MAX(cbSrc * 8, _1M); void *pvDst = RTMemAllocZ(cbDst); rc = RTZipBlockDecompress(RTZIPTYPE_ZLIB, 0, pvSrc, cbSrc, &cbSrcActually, pvDst, cbDst, &cbDstActually); RTTestIPrintf(RTTESTLVL_ALWAYS, "cbSrc=%zu cbSrcActually=%zu cbDst=%zu cbDstActually=%zu rc=%Rrc\n", cbSrc, cbSrcActually, cbDst, cbDstActually, rc); RTTESTI_CHECK_RC_OK(rc); }
static void tstObjectCreateTemp(const char *pszSubTest, const char *pszTemplate, bool fFile, RTFMODE fMode, unsigned cTimes, bool fSkipXCheck) { RTTestISub(pszSubTest); const char *pcszAPI = fFile ? "RTFileCreateTemp" : "RTDirCreateTemp"; /* Allocate the result array. */ char **papszNames = (char **)RTMemTmpAllocZ(cTimes * sizeof(char *)); RTTESTI_CHECK_RETV(papszNames != NULL); /* The test loop. */ unsigned i; for (i = 0; i < cTimes; i++) { int rc; char szName[RTPATH_MAX]; RTFMODE fModeFinal; RTTESTI_CHECK_RC(rc = RTPathAppend(strcpy(szName, g_szTempPath), sizeof(szName), pszTemplate), VINF_SUCCESS); if (RT_FAILURE(rc)) break; RTTESTI_CHECK(papszNames[i] = RTStrDup(szName)); if (!papszNames[i]) break; rc = fFile ? RTFileCreateTemp(papszNames[i], fMode) : RTDirCreateTemp(papszNames[i], fMode); if (rc != VINF_SUCCESS) { RTTestIFailed("%s(%s, %#o) call #%u -> %Rrc\n", pcszAPI, szName, (int)fMode, i, rc); RTStrFree(papszNames[i]); papszNames[i] = NULL; break; } /* Check that the final permissions are not more permissive than * the ones requested (less permissive is fine, c.f. umask etc.). * I mask out the group as I am not sure how we deal with that on * Windows. */ RTTESTI_CHECK_RC_OK(rc = RTPathGetMode(papszNames[i], &fModeFinal)); if (RT_SUCCESS(rc)) { fModeFinal &= (RTFS_UNIX_IRWXU | RTFS_UNIX_IRWXO); RTTESTI_CHECK_MSG((fModeFinal & ~fMode) == 0, ("%s: szName %s\nfModeFinal ~= %#o, expected %#o\n", pcszAPI, szName, fModeFinal, (int)fMode)); } RTTestIPrintf(RTTESTLVL_DEBUG, "%s: %s\n", pcszAPI, papszNames[i]); RTTESTI_CHECK_MSG(strlen(szName) == strlen(papszNames[i]), ("%s: szName %s\nReturned %s\n", pcszAPI, szName, papszNames[i])); if (!fSkipXCheck) RTTESTI_CHECK_MSG(strchr(RTPathFilename(papszNames[i]), 'X') == NULL, ("%s: szName %s\nReturned %s\n", pcszAPI, szName, papszNames[i])); } /* cleanup */ while (i-- > 0) { if (fFile) RTTESTI_CHECK_RC(RTFileDelete(papszNames[i]), VINF_SUCCESS); else RTTESTI_CHECK_RC(RTDirRemove(papszNames[i]), VINF_SUCCESS); RTStrFree(papszNames[i]); } RTMemTmpFree(papszNames); }
void tstFileAioTestReadWriteBasic(RTFILE File, bool fWrite, void *pvTestBuf, size_t cbTestBuf, size_t cbTestFile, uint32_t cMaxReqsInFlight) { /* Allocate request array. */ RTFILEAIOREQ *paReqs; paReqs = (PRTFILEAIOREQ)RTTestGuardedAllocHead(g_hTest, cMaxReqsInFlight * sizeof(RTFILEAIOREQ)); RTTESTI_CHECK_RETV(paReqs); RT_BZERO(paReqs, sizeof(cMaxReqsInFlight * sizeof(RTFILEAIOREQ))); /* Allocate array holding pointer to data buffers. */ void **papvBuf = (void **)RTTestGuardedAllocHead(g_hTest, cMaxReqsInFlight * sizeof(void *)); RTTESTI_CHECK_RETV(papvBuf); /* Allocate the buffers*/ for (unsigned i = 0; i < cMaxReqsInFlight; i++) { RTTESTI_CHECK_RC_OK_RETV(RTTestGuardedAlloc(g_hTest, cbTestBuf, PAGE_SIZE, true /*fHead*/, &papvBuf[i])); if (fWrite) memcpy(papvBuf[i], pvTestBuf, cbTestBuf); if (fWrite) memcpy(papvBuf[i], pvTestBuf, cbTestBuf); else RT_BZERO(papvBuf[i], cbTestBuf); } /* Allocate array holding completed requests. */ RTFILEAIOREQ *paReqsCompleted; paReqsCompleted = (PRTFILEAIOREQ)RTTestGuardedAllocHead(g_hTest, cMaxReqsInFlight * sizeof(RTFILEAIOREQ)); RTTESTI_CHECK_RETV(paReqsCompleted); RT_BZERO(paReqsCompleted, cMaxReqsInFlight * sizeof(RTFILEAIOREQ)); /* Create a context and associate the file handle with it. */ RTFILEAIOCTX hAioContext; RTTESTI_CHECK_RC_RETV(RTFileAioCtxCreate(&hAioContext, cMaxReqsInFlight, 0 /* fFlags */), VINF_SUCCESS); RTTESTI_CHECK_RC_RETV(RTFileAioCtxAssociateWithFile(hAioContext, File), VINF_SUCCESS); /* Initialize requests. */ for (unsigned i = 0; i < cMaxReqsInFlight; i++) RTFileAioReqCreate(&paReqs[i]); RTFOFF off = 0; int cRuns = 0; uint64_t NanoTS = RTTimeNanoTS(); size_t cbLeft = cbTestFile; while (cbLeft) { int rc; int cReqs = 0; for (unsigned i = 0; i < cMaxReqsInFlight; i++) { size_t cbTransfer = cbLeft < cbTestBuf ? cbLeft : cbTestBuf; if (!cbTransfer) break; if (fWrite) rc = RTFileAioReqPrepareWrite(paReqs[i], File, off, papvBuf[i], cbTransfer, papvBuf[i]); else rc = RTFileAioReqPrepareRead(paReqs[i], File, off, papvBuf[i], cbTransfer, papvBuf[i]); RTTESTI_CHECK_RC(rc, VINF_SUCCESS); cbLeft -= cbTransfer; off += cbTransfer; cReqs++; } rc = RTFileAioCtxSubmit(hAioContext, paReqs, cReqs); RTTESTI_CHECK_MSG(rc == VINF_SUCCESS, ("Failed to submit tasks after %d runs. rc=%Rrc\n", cRuns, rc)); if (rc != VINF_SUCCESS) break; /* Wait */ uint32_t cCompleted = 0; RTTESTI_CHECK_RC(rc = RTFileAioCtxWait(hAioContext, cReqs, RT_INDEFINITE_WAIT, paReqsCompleted, cMaxReqsInFlight, &cCompleted), VINF_SUCCESS); if (rc != VINF_SUCCESS) break; if (!fWrite) { for (uint32_t i = 0; i < cCompleted; i++) { /* Compare that we read the right stuff. */ void *pvBuf = RTFileAioReqGetUser(paReqsCompleted[i]); RTTESTI_CHECK(pvBuf); size_t cbTransfered; RTTESTI_CHECK_RC(rc = RTFileAioReqGetRC(paReqsCompleted[i], &cbTransfered), VINF_SUCCESS); if (rc != VINF_SUCCESS) break; RTTESTI_CHECK_MSG(cbTransfered == cbTestBuf, ("cbTransfered=%zd\n", cbTransfered)); RTTESTI_CHECK_RC_OK(rc = (memcmp(pvBuf, pvTestBuf, cbTestBuf) == 0 ? VINF_SUCCESS : VERR_BAD_EXE_FORMAT)); if (rc != VINF_SUCCESS) break; memset(pvBuf, 0, cbTestBuf); } } cRuns++; if (RT_FAILURE(rc)) break; } NanoTS = RTTimeNanoTS() - NanoTS; uint64_t SpeedKBs = (uint64_t)(cbTestFile / (NanoTS / 1000000000.0) / 1024); RTTestValue(g_hTest, "Throughput", SpeedKBs, RTTESTUNIT_KILOBYTES_PER_SEC); /* cleanup */ for (unsigned i = 0; i < cMaxReqsInFlight; i++) RTTestGuardedFree(g_hTest, papvBuf[i]); RTTestGuardedFree(g_hTest, papvBuf); for (unsigned i = 0; i < cMaxReqsInFlight; i++) RTTESTI_CHECK_RC(RTFileAioReqDestroy(paReqs[i]), VINF_SUCCESS); RTTESTI_CHECK_RC(RTFileAioCtxDestroy(hAioContext), VINF_SUCCESS); RTTestGuardedFree(g_hTest, paReqs); }
/** * Do the bi-directional transfer test. */ static void tstBidirectionalTransfer(PTSTSTATE pThis, uint32_t cbFrame) { MYARGS Args0; RT_ZERO(Args0); Args0.hIf = pThis->hIf0; Args0.pBuf = pThis->pBuf0; Args0.Mac.au16[0] = 0x8086; Args0.Mac.au16[1] = 0; Args0.Mac.au16[2] = 0; Args0.cbFrame = cbFrame; MYARGS Args1; RT_ZERO(Args1); Args1.hIf = pThis->hIf1; Args1.pBuf = pThis->pBuf1; Args1.Mac.au16[0] = 0x8086; Args1.Mac.au16[1] = 0; Args1.Mac.au16[2] = 1; Args1.cbFrame = cbFrame; RTTHREAD ThreadRecv0 = NIL_RTTHREAD; RTTHREAD ThreadRecv1 = NIL_RTTHREAD; RTTHREAD ThreadSend0 = NIL_RTTHREAD; RTTHREAD ThreadSend1 = NIL_RTTHREAD; RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadRecv0, ReceiveThread, &Args0, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "RECV0")); RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadRecv1, ReceiveThread, &Args1, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "RECV1")); RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadSend0, SendThread, &Args0, 0, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "SEND0")); RTTESTI_CHECK_RC_OK_RETV(RTThreadCreate(&ThreadSend1, SendThread, &Args1, 0, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "SEND1")); int rc2 = VINF_SUCCESS; int rc; RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadSend0, 5*60*1000, &rc2)); if (RT_SUCCESS(rc)) { RTTESTI_CHECK_RC_OK(rc2); ThreadSend0 = NIL_RTTHREAD; RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadSend1, 5*60*1000, RT_SUCCESS(rc2) ? &rc2 : NULL)); if (RT_SUCCESS(rc)) { ThreadSend1 = NIL_RTTHREAD; RTTESTI_CHECK_RC_OK(rc2); } } if (RTTestErrorCount(g_hTest) == 0) { /* * Wait a bit for the receivers to finish up. */ unsigned cYields = 100000; while ( ( IntNetRingHasMoreToRead(&pThis->pBuf0->Recv) || IntNetRingHasMoreToRead(&pThis->pBuf1->Recv)) && cYields-- > 0) RTThreadYield(); uint64_t u64Elapsed = RT_MAX(Args0.u64End, Args1.u64End) - RT_MIN(Args0.u64Start, Args1.u64Start); uint64_t u64Speed = (uint64_t)((2 * g_cbTransfer / 1024) / (u64Elapsed / 1000000000.0)); RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "transferred %u bytes in %'RU64 ns (%'RU64 KB/s)\n", 2 * g_cbTransfer, u64Elapsed, u64Speed); /* * Wait for the threads to finish up... */ RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadRecv0, 5000, &rc2)); if (RT_SUCCESS(rc)) { RTTESTI_CHECK_RC_OK(rc2); ThreadRecv0 = NIL_RTTHREAD; } RTTESTI_CHECK_RC_OK(rc = RTThreadWait(ThreadRecv1, 5000, &rc2)); if (RT_SUCCESS(rc)) { RTTESTI_CHECK_RC_OK(rc2); ThreadRecv1 = NIL_RTTHREAD; } } /* * Give them a chance to complete... */ RTThreadWait(ThreadRecv0, 5000, NULL); RTThreadWait(ThreadRecv1, 5000, NULL); RTThreadWait(ThreadSend0, 5000, NULL); RTThreadWait(ThreadSend1, 5000, NULL); /* * Display statistics. */ RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Buf0: Yields-OK=%llu Yields-NOK=%llu Lost=%llu Bad=%llu\n", pThis->pBuf0->cStatYieldsOk.c, pThis->pBuf0->cStatYieldsNok.c, pThis->pBuf0->cStatLost.c, pThis->pBuf0->cStatBadFrames.c); RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Buf0.Recv: Frames=%llu Bytes=%llu Overflows=%llu\n", pThis->pBuf0->Recv.cStatFrames, pThis->pBuf0->Recv.cbStatWritten.c, pThis->pBuf0->Recv.cOverflows.c); RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Buf0.Send: Frames=%llu Bytes=%llu Overflows=%llu\n", pThis->pBuf0->Send.cStatFrames, pThis->pBuf0->Send.cbStatWritten.c, pThis->pBuf0->Send.cOverflows.c); RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Buf1: Yields-OK=%llu Yields-NOK=%llu Lost=%llu Bad=%llu\n", pThis->pBuf1->cStatYieldsOk.c, pThis->pBuf1->cStatYieldsNok.c, pThis->pBuf1->cStatLost.c, pThis->pBuf1->cStatBadFrames.c); RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Buf1.Recv: Frames=%llu Bytes=%llu Overflows=%llu\n", pThis->pBuf1->Recv.cStatFrames, pThis->pBuf1->Recv.cbStatWritten.c, pThis->pBuf1->Recv.cOverflows.c); RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Buf1.Send: Frames=%llu Bytes=%llu Overflows=%llu\n", pThis->pBuf1->Send.cStatFrames, pThis->pBuf1->Send.cbStatWritten.c, pThis->pBuf1->Send.cOverflows.c); }
static int tstSingle(RTTEST hTest) { RTTestSubF(hTest, "Single buffer"); PDMAUDIOSTREAMCFG config = { 44100, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANESS_LITTLE /* Endianess */ }; PDMPCMPROPS props; int rc = drvAudioStreamCfgToProps(&config, &props); AssertRC(rc); uint32_t cBufSize = _1K; /* * General stuff. */ PDMAUDIOMIXBUF mb; RTTESTI_CHECK_RC_OK(audioMixBufInit(&mb, "Single", &props, cBufSize)); RTTESTI_CHECK(audioMixBufSize(&mb) == cBufSize); RTTESTI_CHECK(AUDIOMIXBUF_B2S(&mb, audioMixBufSizeBytes(&mb)) == cBufSize); RTTESTI_CHECK(AUDIOMIXBUF_S2B(&mb, audioMixBufSize(&mb)) == audioMixBufSizeBytes(&mb)); RTTESTI_CHECK(audioMixBufFree(&mb) == cBufSize); RTTESTI_CHECK(AUDIOMIXBUF_S2B(&mb, audioMixBufFree(&mb)) == audioMixBufFreeBytes(&mb)); /* * Absolute writes. */ uint32_t read = 0, written = 0, written_abs = 0; int8_t samples8 [2] = { 0x12, 0x34 }; int16_t samples16[2] = { 0xAA, 0xBB }; int32_t samples32[2] = { 0xCC, 0xDD }; int64_t samples64[2] = { 0xEE, 0xFF }; RTTESTI_CHECK_RC_OK(audioMixBufWriteAt(&mb, 0, &samples8, sizeof(samples8), &written)); RTTESTI_CHECK(written == 0 /* Samples */); RTTESTI_CHECK_RC_OK(audioMixBufWriteAt(&mb, 0, &samples16, sizeof(samples16), &written)); RTTESTI_CHECK(written == 1 /* Samples */); RTTESTI_CHECK_RC_OK(audioMixBufWriteAt(&mb, 2, &samples32, sizeof(samples32), &written)); RTTESTI_CHECK(written == 2 /* Samples */); written_abs = 0; /* Beyond buffer. */ RTTESTI_CHECK_RC(audioMixBufWriteAt(&mb, audioMixBufSize(&mb) + 1, &samples16, sizeof(samples16), &written), VERR_BUFFER_OVERFLOW); /* * Circular writes. */ size_t cToWrite = audioMixBufSize(&mb) - written_abs - 1; /* -1 as padding plus -2 samples for above. */ for (size_t i = 0; i < cToWrite; i++) { RTTESTI_CHECK_RC_OK(audioMixBufWriteCirc(&mb, &samples16, sizeof(samples16), &written)); RTTESTI_CHECK(written == 1); } RTTESTI_CHECK(!audioMixBufIsEmpty(&mb)); RTTESTI_CHECK(audioMixBufFree(&mb) == 1); RTTESTI_CHECK(audioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, 1U)); RTTESTI_CHECK(audioMixBufProcessed(&mb) == cToWrite + written_abs /* + last absolute write */); RTTESTI_CHECK_RC_OK(audioMixBufWriteCirc(&mb, &samples16, sizeof(samples16), &written)); RTTESTI_CHECK(written == 1); RTTESTI_CHECK(audioMixBufFree(&mb) == 0); RTTESTI_CHECK(audioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, 0)); RTTESTI_CHECK(audioMixBufProcessed(&mb) == cBufSize); /* Circular reads. */ size_t cToRead = audioMixBufSize(&mb) - written_abs - 1; for (size_t i = 0; i < cToWrite; i++) { RTTESTI_CHECK_RC_OK(audioMixBufReadCirc(&mb, &samples16, sizeof(samples16), &read)); RTTESTI_CHECK(read == 1); audioMixBufFinish(&mb, read); } RTTESTI_CHECK(!audioMixBufIsEmpty(&mb)); RTTESTI_CHECK(audioMixBufFree(&mb) == audioMixBufSize(&mb) - written_abs - 1); RTTESTI_CHECK(audioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, cBufSize - written_abs - 1)); RTTESTI_CHECK(audioMixBufProcessed(&mb) == cBufSize - cToRead + written_abs); RTTESTI_CHECK_RC_OK(audioMixBufReadCirc(&mb, &samples16, sizeof(samples16), &read)); RTTESTI_CHECK(read == 1); audioMixBufFinish(&mb, read); RTTESTI_CHECK(audioMixBufFree(&mb) == cBufSize - written_abs); RTTESTI_CHECK(audioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, cBufSize - written_abs)); RTTESTI_CHECK(audioMixBufProcessed(&mb) == written_abs); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; }
static int tstParentChild(RTTEST hTest) { RTTestSubF(hTest, "2 Children -> Parent"); uint32_t cBufSize = _1K; PDMAUDIOSTREAMCFG cfg_p = { 44100, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANESS_LITTLE /* Endianess */ }; PDMPCMPROPS props; int rc = drvAudioStreamCfgToProps(&cfg_p, &props); AssertRC(rc); PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(audioMixBufInit(&parent, "Parent", &props, cBufSize)); PDMAUDIOSTREAMCFG cfg_c1 = /* Upmixing to parent */ { 22100, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANESS_LITTLE /* Endianess */ }; rc = drvAudioStreamCfgToProps(&cfg_c1, &props); AssertRC(rc); PDMAUDIOMIXBUF child1; RTTESTI_CHECK_RC_OK(audioMixBufInit(&child1, "Child1", &props, cBufSize)); RTTESTI_CHECK_RC_OK(audioMixBufLinkTo(&child1, &parent)); PDMAUDIOSTREAMCFG cfg_c2 = /* Downmixing to parent */ { 48000, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANESS_LITTLE /* Endianess */ }; rc = drvAudioStreamCfgToProps(&cfg_c2, &props); AssertRC(rc); PDMAUDIOMIXBUF child2; RTTESTI_CHECK_RC_OK(audioMixBufInit(&child2, "Child2", &props, cBufSize)); RTTESTI_CHECK_RC_OK(audioMixBufLinkTo(&child2, &parent)); /* * Writing + mixing from child/children -> parent, sequential. */ size_t cbBuf = _1K; char pvBuf[_1K]; int16_t samples[32] = { 0xAA, 0xBB }; uint32_t free, read , written, proc, mixed, temp; uint32_t cChild1Free = cBufSize; uint32_t cChild1Mixed = 0; uint32_t cSamplesParent1 = 16; uint32_t cSamplesChild1 = 16; uint32_t cChild2Free = cBufSize; uint32_t cChild2Mixed = 0; uint32_t cSamplesParent2 = 16; uint32_t cSamplesChild2 = 16; uint32_t t = RTRandU32() % 64; for (uint32_t i = 0; i < t; i++) { RTTestPrintf(hTest, RTTESTLVL_DEBUG, "i=%RU32\n", i); RTTESTI_CHECK_RC_OK_BREAK(audioMixBufWriteAt(&child1, 0, &samples, sizeof(samples), &written)); RTTESTI_CHECK_MSG_BREAK(written == cSamplesChild1, ("Child1: Expected %RU32 written samples, got %RU32\n", cSamplesChild1, written)); RTTESTI_CHECK_RC_OK_BREAK(audioMixBufMixToParent(&child1, written, &mixed)); temp = audioMixBufProcessed(&parent) - audioMixBufMixed(&child2); RTTESTI_CHECK_MSG_BREAK(audioMixBufMixed(&child1) == temp, ("Child1: Expected %RU32 mixed samples, got %RU32\n", audioMixBufMixed(&child1), temp)); RTTESTI_CHECK_RC_OK_BREAK(audioMixBufWriteAt(&child2, 0, &samples, sizeof(samples), &written)); RTTESTI_CHECK_MSG_BREAK(written == cSamplesChild2, ("Child2: Expected %RU32 written samples, got %RU32\n", cSamplesChild2, written)); RTTESTI_CHECK_RC_OK_BREAK(audioMixBufMixToParent(&child2, written, &mixed)); temp = audioMixBufProcessed(&parent) - audioMixBufMixed(&child1); RTTESTI_CHECK_MSG_BREAK(audioMixBufMixed(&child2) == temp, ("Child2: Expected %RU32 mixed samples, got %RU32\n", audioMixBufMixed(&child2), temp)); } RTTESTI_CHECK(audioMixBufProcessed(&parent) == audioMixBufMixed(&child1) + audioMixBufMixed(&child2)); for (;;) { RTTESTI_CHECK_RC_OK_BREAK(audioMixBufReadCirc(&parent, pvBuf, cbBuf, &read)); if (!read) break; audioMixBufFinish(&parent, read); } RTTESTI_CHECK(audioMixBufProcessed(&parent) == 0); RTTESTI_CHECK(audioMixBufMixed(&child1) == 0); RTTESTI_CHECK(audioMixBufMixed(&child2) == 0); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; }
/* Test volume control. */ static int tstVolume(RTTEST hTest) { unsigned i; uint32_t cBufSize = 256; PDMPCMPROPS props; RTTestSubF(hTest, "Volume control"); /* Same for parent/child. */ PDMAUDIOSTREAMCFG cfg = { 44100, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */ }; int rc = DrvAudioStreamCfgToProps(&cfg, &props); AssertRC(rc); PDMAUDIOVOLUME vol = { false, 0, 0 }; /* Not muted. */ PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&parent, "Parent", &props, cBufSize)); PDMAUDIOMIXBUF child; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&child, "Child", &props, cBufSize)); RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child, &parent)); /* A few 16-bit signed samples. */ int16_t samples[16] = { INT16_MIN, INT16_MIN + 1, -128, -64, -4, -1, 0, 1, 2, 255, 256, INT16_MAX / 2, INT16_MAX - 2, INT16_MAX - 1, INT16_MAX, 0 }; /* * Writing + mixing from child -> parent. */ uint32_t cbBuf = 256; char achBuf[256]; uint32_t read, written, mixed; uint32_t cChildFree = cBufSize; uint32_t cChildMixed = 0; uint32_t cSamplesChild = 8; uint32_t cSamplesParent = cSamplesChild; uint32_t cSamplesRead; int16_t *pSrc16; int16_t *pDst16; /**** Volume control test ****/ RTTestPrintf(hTest, RTTESTLVL_DEBUG, "Volume control test %uHz %uch \n", cfg.uHz, cfg.cChannels); /* 1) Full volume/0dB attenuation (255). */ vol.uLeft = vol.uRight = 255; AudioMixBufSetVolume(&child, &vol); RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&child, 0, &samples, sizeof(samples), &written)); RTTESTI_CHECK_MSG(written == cSamplesChild, ("Child: Expected %RU32 written samples, got %RU32\n", cSamplesChild, written)); RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, written, &mixed)); cSamplesRead = 0; for (;;) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &read)); if (!read) break; cSamplesRead += read; AudioMixBufFinish(&parent, read); } RTTESTI_CHECK_MSG(cSamplesRead == cSamplesParent, ("Parent: Expected %RU32 mixed samples, got %RU32\n", cSamplesParent, cSamplesRead)); /* Check that at 0dB the samples came out unharmed. */ pSrc16 = &samples[0]; pDst16 = (int16_t *)achBuf; for (i = 0; i < cSamplesParent * 2 /* stereo */; ++i) { RTTESTI_CHECK_MSG(*pSrc16 == *pDst16, ("index %u: Dst=%d, Src=%d\n", i, *pDst16, *pSrc16)); ++pSrc16; ++pDst16; } AudioMixBufReset(&child); /* 2) Half volume/-6dB attenuation (16 steps down). */ vol.uLeft = vol.uRight = 255 - 16; AudioMixBufSetVolume(&child, &vol); RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&child, 0, &samples, sizeof(samples), &written)); RTTESTI_CHECK_MSG(written == cSamplesChild, ("Child: Expected %RU32 written samples, got %RU32\n", cSamplesChild, written)); RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, written, &mixed)); cSamplesRead = 0; for (;;) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &read)); if (!read) break; cSamplesRead += read; AudioMixBufFinish(&parent, read); } RTTESTI_CHECK_MSG(cSamplesRead == cSamplesParent, ("Parent: Expected %RU32 mixed samples, got %RU32\n", cSamplesParent, cSamplesRead)); /* Check that at -6dB the sample values are halved. */ pSrc16 = &samples[0]; pDst16 = (int16_t *)achBuf; for (i = 0; i < cSamplesParent * 2 /* stereo */; ++i) { /* Watch out! For negative values, x >> 1 is not the same as x / 2. */ RTTESTI_CHECK_MSG(*pSrc16 >> 1 == *pDst16, ("index %u: Dst=%d, Src=%d\n", i, *pDst16, *pSrc16)); ++pSrc16; ++pDst16; } AudioMixBufDestroy(&parent); AudioMixBufDestroy(&child); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; }
/* Test 16-bit sample conversion (16-bit -> internal -> 16-bit). */ static int tstConversion16(RTTEST hTest) { unsigned i; uint32_t cBufSize = 256; PDMPCMPROPS props; RTTestSubF(hTest, "Sample conversion 16-bit"); PDMAUDIOSTREAMCFG cfg_p = { 44100, /* Hz */ 1 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */ }; int rc = DrvAudioStreamCfgToProps(&cfg_p, &props); AssertRC(rc); PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&parent, "Parent", &props, cBufSize)); PDMAUDIOSTREAMCFG cfg_c = /* Upmixing to parent */ { 22050, /* Hz */ 1 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */ }; rc = DrvAudioStreamCfgToProps(&cfg_c, &props); AssertRC(rc); PDMAUDIOMIXBUF child; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&child, "Child", &props, cBufSize)); RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child, &parent)); /* 16-bit signed. More or less exclusively used as output, and usually as input, too. */ int16_t samples[16] = { 0xAA, 0xBB, INT16_MIN, INT16_MIN + 1, INT16_MIN / 2, -3, -2, -1, 0, 1, 2, 3, INT16_MAX / 2, INT16_MAX - 1, INT16_MAX, 0 }; /* * Writing + mixing from child -> parent, sequential. */ uint32_t cbBuf = 256; char achBuf[256]; uint32_t read, written, mixed, temp; uint32_t cChildFree = cBufSize; uint32_t cChildMixed = 0; uint32_t cSamplesChild = 16; uint32_t cSamplesParent = cSamplesChild * 2 - 2; uint32_t cSamplesRead = 0; /**** 16-bit signed samples ****/ RTTestPrintf(hTest, RTTESTLVL_DEBUG, "Conversion test %uHz %uch 16-bit\n", cfg_c.uHz, cfg_c.cChannels); RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&child, 0, &samples, sizeof(samples), &written)); RTTESTI_CHECK_MSG(written == cSamplesChild, ("Child: Expected %RU32 written samples, got %RU32\n", cSamplesChild, written)); RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, written, &mixed)); temp = AudioMixBufProcessed(&parent); RTTESTI_CHECK_MSG(AudioMixBufMixed(&child) == temp, ("Child: Expected %RU32 mixed samples, got %RU32\n", AudioMixBufMixed(&child), temp)); RTTESTI_CHECK(AudioMixBufProcessed(&parent) == AudioMixBufMixed(&child)); for (;;) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &read)); if (!read) break; cSamplesRead += read; AudioMixBufFinish(&parent, read); } RTTESTI_CHECK_MSG(cSamplesRead == cSamplesParent, ("Parent: Expected %RU32 mixed samples, got %RU32\n", cSamplesParent, cSamplesRead)); /* Check that the samples came out unharmed. Every other sample is interpolated and we ignore it. */ /* NB: This also checks that the default volume setting is 0dB attenuation. */ int16_t *pSrc16 = &samples[0]; int16_t *pDst16 = (int16_t *)achBuf; for (i = 0; i < cSamplesChild - 1; ++i) { RTTESTI_CHECK_MSG(*pSrc16 == *pDst16, ("index %u: Dst=%d, Src=%d\n", i, *pDst16, *pSrc16)); pSrc16 += 1; pDst16 += 2; } RTTESTI_CHECK(AudioMixBufProcessed(&parent) == 0); RTTESTI_CHECK(AudioMixBufMixed(&child) == 0); AudioMixBufDestroy(&parent); AudioMixBufDestroy(&child); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; }
/* Test 8-bit sample conversion (8-bit -> internal -> 8-bit). */ static int tstConversion8(RTTEST hTest) { unsigned i; uint32_t cBufSize = 256; PDMPCMPROPS props; RTTestSubF(hTest, "Sample conversion"); PDMAUDIOSTREAMCFG cfg_p = { 44100, /* Hz */ 1 /* Channels */, AUD_FMT_U8 /* Format */, PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */ }; int rc = DrvAudioStreamCfgToProps(&cfg_p, &props); AssertRC(rc); PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&parent, "Parent", &props, cBufSize)); /* Child uses half the sample rate; that ensures the mixing engine can't * take shortcuts and performs conversion. Because conversion to double * the sample rate effectively inserts one additional sample between every * two source samples, N source samples will be converted to N * 2 - 1 * samples. However, the last source sample will be saved for later * interpolation and not immediately output. */ PDMAUDIOSTREAMCFG cfg_c = /* Upmixing to parent */ { 22050, /* Hz */ 1 /* Channels */, AUD_FMT_U8 /* Format */, PDMAUDIOENDIANNESS_LITTLE /* ENDIANNESS */ }; rc = DrvAudioStreamCfgToProps(&cfg_c, &props); AssertRC(rc); PDMAUDIOMIXBUF child; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&child, "Child", &props, cBufSize)); RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child, &parent)); /* 8-bit unsigned samples. Often used with SB16 device. */ uint8_t samples[16] = { 0xAA, 0xBB, 0, 1, 43, 125, 126, 127, 128, 129, 130, 131, 132, UINT8_MAX - 1, UINT8_MAX, 0 }; /* * Writing + mixing from child -> parent, sequential. */ uint32_t cbBuf = 256; char achBuf[256]; uint32_t read, written, mixed, temp; uint32_t cChildFree = cBufSize; uint32_t cChildMixed = 0; uint32_t cSamplesChild = 16; uint32_t cSamplesParent = cSamplesChild * 2 - 2; uint32_t cSamplesRead = 0; /**** 8-bit unsigned samples ****/ RTTestPrintf(hTest, RTTESTLVL_DEBUG, "Conversion test %uHz %uch 8-bit\n", cfg_c.uHz, cfg_c.cChannels); RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&child, 0, &samples, sizeof(samples), &written)); RTTESTI_CHECK_MSG(written == cSamplesChild, ("Child: Expected %RU32 written samples, got %RU32\n", cSamplesChild, written)); RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, written, &mixed)); temp = AudioMixBufProcessed(&parent); RTTESTI_CHECK_MSG(AudioMixBufMixed(&child) == temp, ("Child: Expected %RU32 mixed samples, got %RU32\n", AudioMixBufMixed(&child), temp)); RTTESTI_CHECK(AudioMixBufProcessed(&parent) == AudioMixBufMixed(&child)); for (;;) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &read)); if (!read) break; cSamplesRead += read; AudioMixBufFinish(&parent, read); } RTTESTI_CHECK_MSG(cSamplesRead == cSamplesParent, ("Parent: Expected %RU32 mixed samples, got %RU32\n", cSamplesParent, cSamplesRead)); /* Check that the samples came out unharmed. Every other sample is interpolated and we ignore it. */ /* NB: This also checks that the default volume setting is 0dB attenuation. */ uint8_t *pSrc8 = &samples[0]; uint8_t *pDst8 = (uint8_t *)achBuf; for (i = 0; i < cSamplesChild - 1; ++i) { RTTESTI_CHECK_MSG(*pSrc8 == *pDst8, ("index %u: Dst=%d, Src=%d\n", i, *pDst8, *pSrc8)); pSrc8 += 1; pDst8 += 2; } RTTESTI_CHECK(AudioMixBufProcessed(&parent) == 0); RTTESTI_CHECK(AudioMixBufMixed(&child) == 0); AudioMixBufDestroy(&parent); AudioMixBufDestroy(&child); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; }