VirtualBox

Changeset 89431 in vbox for trunk/src/VBox/ValidationKit


Ignore:
Timestamp:
Jun 1, 2021 12:57:36 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
144785
Message:

Audio/ValKit: More infrastructure code. bugref:10008

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/ValidationKit/utils/audio/vkat.cpp

    r89417 r89431  
    179179    AUDIOTESTMODE           enmMode;
    180180    /** Output path for storing the test environment's final test files. */
     181    char                    szTag[AUDIOTEST_TAG_MAX];
     182    /** Output path for storing the test environment's final test files. */
    181183    char                    szPathOut[RTPATH_MAX];
    182184    /** Temporary path for this test environment. */
    … …  
    235237*********************************************************************************************************************************/
    236238static int audioTestCombineParms(PAUDIOTESTPARMS pBaseParms, PAUDIOTESTPARMS pOverrideParms);
    237 static int audioTestPlayTone(PAUDIOTESTENV pTstEnv, PAUDIOTESTSTREAM pStream, PAUDIOTESTTONEPARMS pParms);
     239static int audioTestCreateStreamDefaultOut(PAUDIOTESTENV pTstEnv, PAUDIOTESTSTREAM pStream, PPDMAUDIOPCMPROPS pProps);
    238240static int audioTestStreamDestroy(PAUDIOTESTENV pTstEnv, PAUDIOTESTSTREAM pStream);
     241static int audioTestDevicesEnumerateAndCheck(PAUDIOTESTENV pTstEnv, const char *pszDev, PPDMAUDIOHOSTDEV *ppDev);
     242static int audioTestEnvPrologue(PAUDIOTESTENV pTstEnv);
    239243
    240244static RTEXITCODE audioTestUsage(PRTSTREAM pStrm);
    … …  
    393397
    394398/*********************************************************************************************************************************
     399*   Test Primitives                                                                                                              *
     400*********************************************************************************************************************************/
     401
     402/**
     403 * Plays a test tone on a specific audio test stream.
     404 *
     405 * @returns VBox status code.
     406 * @param   pTstEnv             Test environment to use for running the test.
     407 * @param   pStream             Stream to use for playing the tone.
     408 * @param   pParms              Tone parameters to use.
     409 *
     410 * @note    Blocking function.
     411 */
     412static int audioTestPlayTone(PAUDIOTESTENV pTstEnv, PAUDIOTESTSTREAM pStream, PAUDIOTESTTONEPARMS pParms)
     413{
     414    AUDIOTESTTONE TstTone;
     415    AudioTestToneInit(&TstTone, &pParms->Props, pParms->dbFreqHz);
     416
     417    const char *pcszPathOut = pTstEnv->Set.szPathAbs;
     418
     419    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Playing test tone (tone frequency is %RU16Hz, %RU32ms)\n", (uint16_t)pParms->dbFreqHz, pParms->msDuration);
     420    RTTestPrintf(g_hTest, RTTESTLVL_DEBUG,  "Writing to '%s'\n", pcszPathOut);
     421
     422    /** @todo Use .WAV here? */
     423    PAUDIOTESTOBJ pObj;
     424    int rc = AudioTestSetObjCreateAndRegister(&pTstEnv->Set, "tone-play.pcm", &pObj);
     425    AssertRCReturn(rc, rc);
     426
     427    if (audioTestDriverStackStreamIsOkay(&pTstEnv->DrvStack, pStream->pStream))
     428    {
     429        uint32_t cbBuf;
     430        uint8_t  abBuf[_4K];
     431
     432        const uint16_t cSchedulingMs = RTRandU32Ex(10, 80); /* Choose a random scheduling (in ms). */
     433        const uint32_t cbPerMs       = PDMAudioPropsMilliToBytes(&pParms->Props, cSchedulingMs);
     434                size_t cbToWrite     = PDMAudioPropsMilliToBytes(&pParms->Props, pParms->msDuration);
     435
     436        AudioTestSetObjAddMetadataStr(pObj, "schedule_ms=%RU16", cSchedulingMs);
     437
     438        while (cbToWrite)
     439        {
     440            uint32_t cbWritten    = 0;
     441            uint32_t cbToGenerate = RT_MIN(cbToWrite, RT_MIN(cbPerMs, sizeof(abBuf)));
     442            Assert(cbToGenerate);
     443
     444            rc = AudioTestToneGenerate(&TstTone, abBuf, cbToGenerate, &cbBuf);
     445            if (RT_SUCCESS(rc))
     446            {
     447                /* Write stuff to disk before trying to play it. Help analysis later. */
     448                rc = AudioTestSetObjWrite(pObj, abBuf, cbBuf);
     449                if (RT_SUCCESS(rc))
     450                    rc = audioTestDriverStackStreamPlay(&pTstEnv->DrvStack, pStream->pStream,
     451                                                        abBuf, cbBuf, &cbWritten);
     452            }
     453
     454            if (RT_FAILURE(rc))
     455                break;
     456
     457            RTThreadSleep(cSchedulingMs);
     458
     459            Assert(cbToWrite >= cbWritten);
     460            cbToWrite -= cbWritten;
     461        }
     462    }
     463    else
     464        rc = VERR_AUDIO_STREAM_NOT_READY;
     465
     466    int rc2 = AudioTestSetObjClose(pObj);
     467    if (RT_SUCCESS(rc))
     468        rc = rc2;
     469
     470    RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Play tone done\n");
     471
     472    return rc;
     473}
     474
     475/*********************************************************************************************************************************
    395476*   ATS Callback Implementations                                                                                                 *
    396477*********************************************************************************************************************************/
    397478
    398 /**
    399  * Note: Called within server (client serving) thread.
    400  */
    401 static DECLCALLBACK(int) audioTestSvcTonePlayCallback(void const *pvUser, PPDMAUDIOSTREAMCFG pStreamCfg, PAUDIOTESTTONEPARMS pToneParms)
     479/** @copydoc ATSCALLBACKS::pfnTestSetBegin */
     480static DECLCALLBACK(int) audioTestSvcTestSetBeginCallback(void const *pvUser, const char *pszTag)
    402481{
    403482    PATSCALLBACKCTX pCtx    = (PATSCALLBACKCTX)pvUser;
    404483    PAUDIOTESTENV   pTstEnv = pCtx->pTstEnv;
    405484
     485    RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Beginning test set '%s'\n", pszTag);
     486
     487    return AudioTestSetCreate(&pTstEnv->Set, pTstEnv->szPathTemp, pszTag);
     488}
     489
     490/** @copydoc ATSCALLBACKS::pfnTestSetEnd */
     491static DECLCALLBACK(int) audioTestSvcTestSetEndCallback(void const *pvUser, const char *pszTag)
     492{
     493    RT_NOREF(pszTag);
     494
     495    PATSCALLBACKCTX pCtx    = (PATSCALLBACKCTX)pvUser;
     496    PAUDIOTESTENV   pTstEnv = pCtx->pTstEnv;
     497
     498    RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Ending test set '%s'\n", pszTag);
     499
     500    return audioTestEnvPrologue(pTstEnv);
     501}
     502
     503/** @copydoc ATSCALLBACKS::pfnTonePlay */
     504static DECLCALLBACK(int) audioTestSvcTonePlayCallback(void const *pvUser, PPDMAUDIOSTREAMCFG pStreamCfg, PAUDIOTESTTONEPARMS pToneParms)
     505{
     506    PATSCALLBACKCTX pCtx    = (PATSCALLBACKCTX)pvUser;
     507    PAUDIOTESTENV   pTstEnv = pCtx->pTstEnv;
     508
    406509    AUDIOTESTTONE TstTone;
    407510    AudioTestToneInitRandom(&TstTone, &pStreamCfg->Props);
    408511
    409     int rc;
    410 
    411     const PPDMAUDIOSTREAM pStream = pTstEnv->aStreams[0].pStream; /** @todo Make this dynamic. */
    412 
    413     if (audioTestDriverStackStreamIsOkay(&pTstEnv->DrvStack, pStream))
    414     {
    415         uint32_t cbBuf;
    416         uint8_t  abBuf[_4K];
    417 
    418         const uint64_t tsStartMs     = RTTimeMilliTS();
    419         const uint16_t cSchedulingMs = RTRandU32Ex(10, 80); /* Chose a random scheduling (in ms). */
    420         const uint32_t cbPerMs       = PDMAudioPropsMilliToBytes(&pStream->Props, cSchedulingMs);
    421 
    422         do
    423         {
    424             rc = AudioTestToneGenerate(&TstTone, abBuf, RT_MIN(cbPerMs, sizeof(abBuf)), &cbBuf);
     512    const PAUDIOTESTSTREAM pTstStream = &pTstEnv->aStreams[0]; /** @todo Make this dynamic. */
     513
     514    int rc = audioTestCreateStreamDefaultOut(pTstEnv, pTstStream, &pStreamCfg->Props);
     515    if (RT_SUCCESS(rc))
     516    {
     517        AUDIOTESTPARMS TstParms;
     518        RT_ZERO(TstParms);
     519        TstParms.enmType  = AUDIOTESTTYPE_TESTTONE_PLAY;
     520        TstParms.enmDir   = PDMAUDIODIR_OUT;
     521        TstParms.TestTone = *pToneParms;
     522
     523        PAUDIOTESTENTRY pTst;
     524        rc = AudioTestSetTestBegin(&pTstEnv->Set, "Playing test tone", &TstParms, &pTst);
     525        if (RT_SUCCESS(rc))
     526        {
     527            rc = audioTestPlayTone(pTstEnv, pTstStream, pToneParms);
    425528            if (RT_SUCCESS(rc))
    426529            {
    427                 uint32_t cbWritten;
    428                 rc = audioTestDriverStackStreamPlay(&pTstEnv->DrvStack, pStream, abBuf, cbBuf, &cbWritten);
     530                AudioTestSetTestDone(pTst);
    429531            }
    430 
    431             if (RTTimeMilliTS() - tsStartMs >= pToneParms->msDuration)
    432                 break;
    433 
    434             if (RT_FAILURE(rc))
    435                 break;
    436 
    437             RTThreadSleep(cSchedulingMs);
    438 
    439         } while (RT_SUCCESS(rc));
     532            else
     533                AudioTestSetTestFailed(pTst, rc, "Playing tone failed");
     534        }
     535
     536        int rc2 = audioTestStreamDestroy(pTstEnv, pTstStream);
     537        if (RT_SUCCESS(rc))
     538            rc = rc2;
    440539    }
    441540    else
    442         rc = VERR_AUDIO_STREAM_NOT_READY;
     541        RTTestFailed(g_hTest, "Error creating output stream, rc=%Rrc\n", rc);
    443542
    444543    return rc;
    … …  
    464563                            const char *pszTcpAddr, uint32_t uTcpPort)
    465564{
    466     PDMAudioHostEnumInit(&pTstEnv->DevEnum);
    467 
    468     int rc = audioTestDriverStackInit(&pTstEnv->DrvStack, pDrvReg, fWithDrvAudio);
    469     if (RT_FAILURE(rc))
    470         return rc;
    471 
    472565    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test mode is '%s'\n", pTstEnv->enmMode == AUDIOTESTMODE_HOST ? "host" : "guest");
    473566    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Using tag '%s'\n", pszTag);
    … …  
    475568    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Temp directory is '%s'\n", pTstEnv->szPathTemp);
    476569
     570    int rc = VINF_SUCCESS;
     571
     572    PDMAudioHostEnumInit(&pTstEnv->DevEnum);
     573
     574    /* Only the guest mode needs initializing the driver stack. */
     575    const bool fUseDriverStack = pTstEnv->enmMode == AUDIOTESTMODE_GUEST;
     576    if (fUseDriverStack)
     577    {
     578        rc = audioTestDriverStackInit(&pTstEnv->DrvStack, pDrvReg, fWithDrvAudio);
     579        if (RT_FAILURE(rc))
     580            return rc;
     581
     582        PPDMAUDIOHOSTDEV pDev;
     583        rc = audioTestDevicesEnumerateAndCheck(pTstEnv, NULL /* pszDevice */, &pDev); /** @todo Implement device checking. */
     584        if (RT_FAILURE(rc))
     585            return rc;
     586    }
     587
    477588    char szPathTemp[RTPATH_MAX];
    478589    if (   !strlen(pTstEnv->szPathTemp)
    … …  
    488599        rc = RTPathJoin(pTstEnv->szPathOut, sizeof(pTstEnv->szPathOut), szPathTemp, "vkat");
    489600
    490     if (RT_SUCCESS(rc))
    491         rc = AudioTestSetCreate(&pTstEnv->Set, pTstEnv->szPathTemp, pszTag);
    492 
    493601    if (RT_FAILURE(rc))
    494602        return rc;
    … …  
    501609
    502610        ATSCALLBACKS Callbacks;
    503         Callbacks.pfnTonePlay = audioTestSvcTonePlayCallback;
    504         Callbacks.pvUser      = &Ctx;
     611        Callbacks.pfnTestSetBegin = audioTestSvcTestSetBeginCallback;
     612        Callbacks.pfnTestSetEnd   = audioTestSvcTestSetEndCallback;
     613        Callbacks.pfnTonePlay     = audioTestSvcTonePlayCallback;
     614        Callbacks.pvUser          = &Ctx;
    505615
    506616        RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Starting ATS ...\n");
    … …  
    511621        if (RT_FAILURE(rc))
    512622        {
    513             RTTestFailed(g_hTest, "Initializing ATS failed with %Rrc\n", rc);
     623            RTTestFailed(g_hTest, "Starting ATS failed with %Rrc\n", rc);
    514624            return rc;
    515625        }
    516 
    517         RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "ATS running\n");
    518 
    519         while (!g_fTerminated) /** @todo Implement signal handling. */
    520         {
    521             RTThreadSleep(100);
    522         }
    523 
    524         RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Shutting down ATS ...\n");
    525 
    526         int rc2 = AudioTestSvcShutdown(&pTstEnv->u.Guest.Srv);
    527         if (RT_SUCCESS(rc))
    528             rc = rc2;
    529     }
    530     else
     626    }
     627    else /* Host mode */
    531628    {
    532629        RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Connecting to ATS at %s:%RU32 ...\n", pszTcpAddr, uTcpPort);
     630
    533631        rc = AudioTestSvcClientConnect(&pTstEnv->u.Host.Client, pszTcpAddr, uTcpPort);
    534632        if (RT_FAILURE(rc))
    … …  
    537635            return rc;
    538636        }
    539     }
    540 
    541     audioTestDriverStackDelete(&pTstEnv->DrvStack);
     637
     638        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connected to ATS\n");
     639    }
     640
     641    if (   RT_FAILURE(rc)
     642        && fUseDriverStack)
     643        audioTestDriverStackDelete(&pTstEnv->DrvStack);
    542644
    543645    return rc;
    … …  
    563665    }
    564666
     667    audioTestDriverStackDelete(&pTstEnv->DrvStack);
     668}
     669
     670/**
     671 * Closes, packs up and destroys a test environment.
     672 *
     673 * @returns VBox status code.
     674 * @param   pTstEnv             Test environment to handle.
     675 */
     676static int audioTestEnvPrologue(PAUDIOTESTENV pTstEnv)
     677{
     678    /* Before destroying the test environment, pack up the test set so
     679     * that it's ready for transmission. */
     680    char szFileOut[RTPATH_MAX];
     681    int rc = AudioTestSetPack(&pTstEnv->Set, pTstEnv->szPathOut, szFileOut, sizeof(szFileOut));
     682    if (RT_SUCCESS(rc))
     683        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test set packed up to '%s'\n", szFileOut);
     684
     685    /* Clean up. */
     686    AudioTestSetClose(&pTstEnv->Set);
     687
     688    int rc2 = AudioTestSetWipe(&pTstEnv->Set);
     689    if (RT_SUCCESS(rc))
     690        rc = rc2;
     691
    565692    AudioTestSetDestroy(&pTstEnv->Set);
    566     audioTestDriverStackDelete(&pTstEnv->DrvStack);
     693
     694    return rc;
    567695}
    568696
    … …  
    812940
    813941/**
    814  * Plays a test tone on a specific audio test stream.
    815  *
    816  * @returns VBox status code.
    817  * @param   pTstEnv             Test environment to use for running the test.
    818  * @param   pStream             Stream to use for playing the tone.
    819  * @param   pParms              Tone parameters to use.
    820  *
    821  * @note    Blocking function.
    822  */
    823 static int audioTestPlayTone(PAUDIOTESTENV pTstEnv, PAUDIOTESTSTREAM pStream, PAUDIOTESTTONEPARMS pParms)
    824 {
    825     AUDIOTESTTONE TstTone;
    826     AudioTestToneInit(&TstTone, &pParms->Props, pParms->dbFreqHz);
    827 
    828     const char *pcszPathOut = pTstEnv->Set.szPathAbs;
    829 
    830     RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Playing test tone (tone frequency is %RU16Hz, %RU32ms)\n", (uint16_t)pParms->dbFreqHz, pParms->msDuration);
    831     RTTestPrintf(g_hTest, RTTESTLVL_DEBUG,  "Writing to '%s'\n", pcszPathOut);
    832 
    833     /** @todo Use .WAV here? */
    834     PAUDIOTESTOBJ pObj;
    835     int rc = AudioTestSetObjCreateAndRegister(&pTstEnv->Set, "tone-play.pcm", &pObj);
    836     AssertRCReturn(rc, rc);
    837 
    838     if (audioTestDriverStackStreamIsOkay(&pTstEnv->DrvStack, pStream->pStream))
    839     {
    840         uint32_t cbBuf;
    841         uint8_t  abBuf[_4K];
    842 
    843         const uint64_t tsStartMs     = RTTimeMilliTS();
    844         const uint16_t cSchedulingMs = RTRandU32Ex(10, 80); /* Choose a random scheduling (in ms). */
    845         const uint32_t cbPerMs       = PDMAudioPropsMilliToBytes(&pParms->Props, cSchedulingMs);
    846 
    847         do
    848         {
    849             rc = AudioTestToneGenerate(&TstTone, abBuf, RT_MIN(cbPerMs, sizeof(abBuf)), &cbBuf);
    850             if (RT_SUCCESS(rc))
    851             {
    852                 /* Write stuff to disk before trying to play it. Help analysis later. */
    853                 rc = AudioTestSetObjWrite(pObj, abBuf, cbBuf);
    854                 if (RT_SUCCESS(rc))
    855                 {
    856                     uint32_t cbWritten;
    857                     rc = audioTestDriverStackStreamPlay(&pTstEnv->DrvStack, pStream->pStream,
    858                                                         abBuf, cbBuf, &cbWritten);
    859                 }
    860             }
    861 
    862             if (RTTimeMilliTS() - tsStartMs >= pParms->msDuration)
    863                 break;
    864 
    865             if (RT_FAILURE(rc))
    866                 break;
    867 
    868             RTThreadSleep(cSchedulingMs);
    869 
    870         } while (RT_SUCCESS(rc));
    871     }
    872     else
    873         rc = VERR_AUDIO_STREAM_NOT_READY;
    874 
    875     int rc2 = AudioTestSetObjClose(pObj);
    876     if (RT_SUCCESS(rc))
    877         rc = rc2;
    878 
    879     return rc;
    880 }
    881 
    882 /**
    883942 * Overrides audio test base parameters with another set.
    884943 *
    … …  
    933992    int rc = VINF_SUCCESS;
    934993
    935     PAUDIOTESTSTREAM pStream = &pTstEnv->aStreams[0];
    936 
    937994    for (uint32_t i = 0; i < pTstParms->cIterations; i++)
    938995    {
    … …  
    9431000        if (RT_SUCCESS(rc))
    9441001        {
    945             rc = audioTestCreateStreamDefaultOut(pTstEnv, pStream, &pTstParms->TestTone.Props);
    946             if (RT_SUCCESS(rc))
    947             {
    948                 rc = audioTestPlayTone(pTstEnv, pStream, &pTstParms->TestTone);
    949             }
    950 
    951             int rc2 = audioTestStreamDestroy(pTstEnv, pStream);
    952             if (RT_SUCCESS(rc))
    953                 rc = rc2;
    954 
     1002            PDMAUDIOSTREAMCFG Cfg;
     1003            RT_ZERO(Cfg);
     1004            /** @todo Add more parameters here? */
     1005            Cfg.Props = pTstParms->Props;
     1006
     1007            rc = AudioTestSvcClientTonePlay(&pTstEnv->u.Host.Client, &Cfg, &pTstParms->TestTone);
    9551008            if (RT_SUCCESS(rc))
    9561009            {
    … …  
    11451198    int rc = VINF_SUCCESS;
    11461199
    1147     unsigned uSeq = 0;
    1148     for (unsigned i = 0; i < RT_ELEMENTS(g_aTests); i++)
    1149     {
    1150         int rc2 = audioTestOne(pTstEnv, &g_aTests[i], uSeq, pOverrideParms);
     1200    if (pTstEnv->enmMode == AUDIOTESTMODE_GUEST)
     1201    {
     1202        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "ATS running\n");
     1203
     1204        while (!g_fTerminated) /** @todo Implement signal handling. */
     1205        {
     1206            RTThreadSleep(100);
     1207        }
     1208
     1209        RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Shutting down ATS ...\n");
     1210
     1211        int rc2 = AudioTestSvcShutdown(&pTstEnv->u.Guest.Srv);
    11511212        if (RT_SUCCESS(rc))
    11521213            rc = rc2;
    1153 
    1154         if (!g_aTests[i].fExcluded)
    1155             uSeq++;
    1156     }
     1214    }
     1215    else if (pTstEnv->enmMode == AUDIOTESTMODE_HOST)
     1216    {
     1217        /* We have one single test set for all executed tests for now. */
     1218        rc = AudioTestSetCreate(&pTstEnv->Set, pTstEnv->szPathTemp, pTstEnv->szTag);
     1219        if (RT_SUCCESS(rc))
     1220        {
     1221            /* Copy back the (eventually generated) tag to the test environment. */
     1222            rc = RTStrCopy(pTstEnv->szTag, sizeof(pTstEnv->szTag), AudioTestSetGetTag(&pTstEnv->Set));
     1223            AssertRC(rc);
     1224
     1225            rc = AudioTestSvcClientTestSetBegin(&pTstEnv->u.Host.Client, pTstEnv->szTag);
     1226            if (RT_SUCCESS(rc))
     1227            {
     1228                unsigned uSeq = 0;
     1229                for (unsigned i = 0; i < RT_ELEMENTS(g_aTests); i++)
     1230                {
     1231                    int rc2 = audioTestOne(pTstEnv, &g_aTests[i], uSeq, pOverrideParms);
     1232                    if (RT_SUCCESS(rc))
     1233                        rc = rc2;
     1234
     1235                    if (!g_aTests[i].fExcluded)
     1236                        uSeq++;
     1237                }
     1238
     1239                int rc2 = AudioTestSvcClientTestSetEnd(&pTstEnv->u.Host.Client, pTstEnv->szTag);
     1240                if (RT_SUCCESS(rc))
     1241                    rc = rc2;
     1242            }
     1243
     1244            audioTestEnvPrologue(pTstEnv);
     1245        }
     1246    }
     1247    else
     1248        AssertFailed();
     1249
     1250    if (RT_FAILURE(rc))
     1251        RTTestFailed(g_hTest, "Test worker failed with %Rrc", rc);
    11571252
    11581253    return rc;
    … …  
    11641259    switch (pOpt->iShort)
    11651260    {
    1166         case 'd':                 return "Go via DrvAudio instead of directly interfacing with the backend.";
    1167         case VKAT_TEST_OPT_DEV:   return "Use the specified audio device";
    1168         case 'e':                 return "Exclude the given test id from the list";
    1169         case 'a':                 return "Exclude all tests from the list (useful to enable single tests later with --include)";
    1170         case 'i':                 return "Include the given test id in the list";
     1261        case 'd':                    return "Go via DrvAudio instead of directly interfacing with the backend";
     1262        case VKAT_TEST_OPT_DEV:      return "Use the specified audio device";
     1263        case VKAT_TEST_OPT_ATS_ADDR: return "ATS address (hostname or IP) to connect to";
     1264        case VKAT_TEST_OPT_ATS_PORT: return "ATS port to connect to. Defaults to 6052 if not set";
     1265        case VKAT_TEST_OPT_MODE:     return "Specifies the mode this program runs at";
     1266        case 'e':                    return "Exclude the given test id from the list";
     1267        case 'a':                    return "Exclude all tests from the list (useful to enable single tests later with --include)";
     1268        case 'i':                    return "Include the given test id in the list";
    11711269    }
    11721270    return NULL;
    … …  
    13361434    if (RT_SUCCESS(rc))
    13371435    {
    1338         PPDMAUDIOHOSTDEV pDev;
    1339         rc = audioTestDevicesEnumerateAndCheck(&TstEnv, pszDevice, &pDev);
    1340         if (RT_SUCCESS(rc))
    1341             audioTestWorker(&TstEnv, &TstCust);
    1342 
    1343         /* Before destroying the test environment, pack up the test set so
    1344          * that it's ready for transmission. */
    1345         char szFileOut[RTPATH_MAX];
    1346         rc = AudioTestSetPack(&TstEnv.Set, TstEnv.szPathOut, szFileOut, sizeof(szFileOut));
    1347         if (RT_SUCCESS(rc))
    1348             RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test set packed up to '%s'\n", szFileOut);
    1349 
    1350 #ifndef DEBUG_andy
    1351         /* Clean up. */
    1352         AudioTestSetClose(&TstEnv.Set); /* wipe fails on windows if the manifest file is open*/
    1353 
    1354         int rc2 = AudioTestSetWipe(&TstEnv.Set);
    1355         AssertRC(rc2); /* Annoying, but not test-critical. */
    1356 #endif
     1436        audioTestWorker(&TstEnv, &TstCust);
    13571437        audioTestEnvDestroy(&TstEnv);
    13581438    }
    … …  
    18631943                    rc = AudioTestSvcInit(&Srv, &Callbacks);
    18641944                    if (RT_SUCCESS(rc))
    1865                     {
    18661945                        rc = AudioTestSvcStart(&Srv);
    1867                         if (RT_SUCCESS(rc))
    1868                             RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "ATS running\n");
    1869                     }
    18701946                }
    18711947                else
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette