VirtualBox

Changeset 89541 in vbox


Ignore:
Timestamp:
Jun 7, 2021 9:26:07 AM (3 years ago)
Author:
vboxsync
Message:

Audio/ValKit: More code for completely self-contained (self) testing. bugref:10008

Location:
trunk/src/VBox
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Audio/AudioTest.cpp

    r89468 r89541  
    292292}
    293293
    294 
    295294/**
    296295 * Return the tag to use in the given buffer, generating one if needed.
    … …  
    302301 * @param   pszTagUser          User specified tag, optional.
    303302 */
    304 int AudioTestCopyOrGenTag(char *pszTag, size_t cbTag, const char *pszTagUser)
     303static int audioTestCopyOrGenTag(char *pszTag, size_t cbTag, const char *pszTagUser)
    305304{
    306305    if (pszTagUser && *pszTagUser)
    … …  
    325324{
    326325    char szTag[AUDIOTEST_TAG_MAX];
    327     int rc = AudioTestCopyOrGenTag(szTag, sizeof(szTag), pszTag);
     326    int rc = audioTestCopyOrGenTag(szTag, sizeof(szTag), pszTag);
    328327    AssertRCReturn(rc, rc);
    329328
    … …  
    674673    audioTestSetInitInternal(pSet);
    675674
    676     int rc = AudioTestCopyOrGenTag(pSet->szTag, sizeof(pSet->szTag), pszTag);
     675    int rc = audioTestCopyOrGenTag(pSet->szTag, sizeof(pSet->szTag), pszTag);
    677676    AssertRCReturn(rc, rc);
    678677

  • trunk/src/VBox/Devices/Audio/AudioTest.h

    r89468 r89541  
    342342int    AudioTestToneParamsInitRandom(PAUDIOTESTTONEPARMS pToneParams, PPDMAUDIOPCMPROPS pProps);
    343343
     344int    AudioTestGenTag(char *pszTag, size_t cbTag);
     345
    344346int    AudioTestPathGetTemp(char *pszPath, size_t cbPath);
    345347int    AudioTestPathCreateTemp(char *pszPath, size_t cbPath, const char *pszUUID);

  • trunk/src/VBox/Devices/Audio/AudioTestService.cpp

    r89458 r89541  
    143143    Log(("atsSendPkt: cb=%#x opcode=%.8s\n", pPkt->cb, pPkt->achOpcode));
    144144    Log2(("%.*Rhxd\n", RT_MIN(pPkt->cb, 256), pPkt));
    145     int rc = pThis->pTransport->pfnSendPkt(pClient->pTransportClient, pPkt);
     145    int rc = pThis->pTransport->pfnSendPkt(&pThis->TransportInst, pClient->pTransportClient, pPkt);
    146146    while (RT_UNLIKELY(rc == VERR_INTERRUPTED) && !pThis->fTerminate)
    147         rc = pThis->pTransport->pfnSendPkt(pClient->pTransportClient, pPkt);
     147        rc = pThis->pTransport->pfnSendPkt(&pThis->TransportInst, pClient->pTransportClient, pPkt);
    148148    if (RT_FAILURE(rc))
    149149        Log(("atsSendPkt: rc=%Rrc\n", rc));
    … …  
    166166    memcpy(Reply.achOpcode, pszOpcode, sizeof(Reply.achOpcode));
    167167
    168     pThis->pTransport->pfnBabble(pClient->pTransportClient, &Reply, 20*1000);
     168    pThis->pTransport->pfnBabble(&pThis->TransportInst, pClient->pTransportClient, &Reply, 20*1000);
    169169}
    170170
    … …  
    187187    {
    188188        PATSPKTHDR pPktHdr;
    189         int rc = pThis->pTransport->pfnRecvPkt(pClient->pTransportClient, &pPktHdr);
     189        int rc = pThis->pTransport->pfnRecvPkt(&pThis->TransportInst, pClient->pTransportClient, &pPktHdr);
    190190        if (RT_SUCCESS(rc))
    191191        {
    … …  
    513513    if (RT_SUCCESS(rc))
    514514    {
    515         pThis->pTransport->pfnNotifyHowdy(pClient->pTransportClient);
     515        pThis->pTransport->pfnNotifyHowdy(&pThis->TransportInst, pClient->pTransportClient);
    516516        pClient->enmState = ATSCLIENTSTATE_READY;
    517517    }
    … …  
    769769                                idxSlt++;
    770770
    771                             rc = pThis->pTransport->pfnPollSetAdd(pThis->hPollSet, pIt->pTransportClient, idxSlt + 1);
     771                            rc = pThis->pTransport->pfnPollSetAdd(&pThis->TransportInst, pThis->hPollSet, pIt->pTransportClient, idxSlt + 1);
    772772                            if (RT_SUCCESS(rc))
    773773                            {
    … …  
    777777                            else
    778778                            {
    779                                 pThis->pTransport->pfnNotifyBye(pIt->pTransportClient);
     779                                pThis->pTransport->pfnNotifyBye(&pThis->TransportInst, pIt->pTransportClient);
    780780                                atsClientDestroy(pIt);
    781781                            }
    … …  
    783783                        else
    784784                        {
    785                             pThis->pTransport->pfnNotifyBye(pIt->pTransportClient);
     785                            pThis->pTransport->pfnNotifyBye(&pThis->TransportInst, pIt->pTransportClient);
    786786                            atsClientDestroy(pIt);
    787787                        }
    … …  
    801801                    {
    802802                        /* Close connection and remove client from array. */
    803                         rc = pThis->pTransport->pfnPollSetRemove(pThis->hPollSet, pClient->pTransportClient, uId);
     803                        rc = pThis->pTransport->pfnPollSetRemove(&pThis->TransportInst, pThis->hPollSet, pClient->pTransportClient, uId);
    804804                        AssertRC(rc);
    805805
    806                         pThis->pTransport->pfnNotifyBye(pClient->pTransportClient);
     806                        pThis->pTransport->pfnNotifyBye(&pThis->TransportInst, pClient->pTransportClient);
    807807                        papClients[uId - 1] = NULL;
    808808                        cClientsCur--;
    … …  
    829829    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
    830830
    831     int rc = VINF_SUCCESS;
     831    int rc = RTThreadUserSignal(hThread);
     832    AssertRCReturn(rc, rc);
    832833
    833834    while (!pThis->fTerminate)
    … …  
    838839         */
    839840        PATSTRANSPORTCLIENT pTransportClient;
    840         rc = pThis->pTransport->pfnWaitForConnect(&pTransportClient);
     841        rc = pThis->pTransport->pfnWaitForConnect(&pThis->TransportInst, &pTransportClient);
    841842        if (RT_FAILURE(rc))
    842843            continue;
    … …  
    866867        {
    867868            RTMsgError("Creating new client structure failed with out of memory error\n");
    868             pThis->pTransport->pfnNotifyBye(pTransportClient);
     869            pThis->pTransport->pfnNotifyBye(&pThis->TransportInst, pTransportClient);
    869870        }
    870871    }
    … …  
    878879 * @returns VBox status code.
    879880 * @param   pThis               The ATS instance.
     881 * @param   pszBindAddr         Bind address. Empty means any address.
     882 *                              If set to NULL, "127.0.0.1" will be used.
     883 * @param   uBindPort           Bind port. If set to 0, ATS_DEFAULT_PORT is being used.
    880884 * @param   pCallbacks          The callbacks table to use.
    881885 *  */
    882 int AudioTestSvcInit(PATSSERVER pThis, PCATSCALLBACKS pCallbacks)
     886int AudioTestSvcInit(PATSSERVER pThis,
     887                     const char *pszBindAddr, uint32_t uBindPort, PCATSCALLBACKS pCallbacks)
    883888{
    884889    memcpy(&pThis->Callbacks, pCallbacks, sizeof(ATSCALLBACKS));
    … …  
    896901     * Initialize the transport layer.
    897902     */
    898     int rc = pThis->pTransport->pfnInit();
     903    int rc = pThis->pTransport->pfnInit(&pThis->TransportInst, pszBindAddr ? pszBindAddr : "127.0.0.1",
     904                                         uBindPort ? uBindPort : ATS_TCP_DEFAULT_PORT);
    899905    if (RT_SUCCESS(rc))
    900906    {
    … …  
    950956                            "AUDTSTSRVM");
    951957    if (RT_SUCCESS(rc))
    952         pThis->fStarted = true;
     958    {
     959        rc = RTThreadUserWait(pThis->hThreadMain, RT_MS_30SEC);
     960        if (RT_SUCCESS(rc))
     961            pThis->fStarted = true;
     962    }
    953963
    954964    return rc;
    … …  
    969979
    970980    if (pThis->pTransport)
    971         pThis->pTransport->pfnTerm();
     981        pThis->pTransport->pfnTerm(&pThis->TransportInst);
    972982
    973983    size_t cbWritten;

  • trunk/src/VBox/Devices/Audio/AudioTestService.h

    r89458 r89541  
    2626
    2727/** Default TCP/IP port the ATS (Audio Test Service) is running on. */
    28 #define ATS_DEFAULT_PORT        6052
     28#define ATS_TCP_DEFAULT_PORT        6052
     29/** Alternative TCP/IP port the ATS (Audio Test Service) is running on. */
     30#define ATS_TCP_ALT_PORT            6042
    2931
    3032/**
    … …  
    7678
    7779/**
     80 * Structure for keeping Audio Test Service (ATS) transport instance-specific data.
     81 *
     82 * Currently only TCP/IP is supported.
     83 */
     84typedef struct ATSTRANSPORTINST
     85{
     86    /** The addresses to bind to.  Empty string means any. */
     87    char                 szTcpBindAddr[256];
     88    /** The TCP port to listen to. */
     89    uint32_t             uTcpBindPort;
     90    /** Pointer to the TCP server instance. */
     91    PRTTCPSERVER         pTcpServer;
     92} ATSTRANSPORTINST;
     93/** Pointer to an Audio Test Service (ATS) TCP/IP transport instance. */
     94typedef ATSTRANSPORTINST *PATSTRANSPORTINSTTCP;
     95
     96/**
    7897 * Structure for keeping an Audio Test Service (ATS) instance.
    7998 */
    … …  
    82101    /** The selected transport layer. */
    83102    PCATSTRANSPORT       pTransport;
     103    /** The transport instance. */
     104    ATSTRANSPORTINST     TransportInst;
    84105    /** The callbacks table. */
    85106    ATSCALLBACKS         Callbacks;
    … …  
    106127typedef ATSSERVER *PATSSERVER;
    107128
    108 int AudioTestSvcInit(PATSSERVER pThis, PCATSCALLBACKS pCallbacks);
     129int AudioTestSvcInit(PATSSERVER pThis, const char *pszBindAddr, uint32_t uBindPort, PCATSCALLBACKS pCallbacks);
    109130int AudioTestSvcDestroy(PATSSERVER pThis);
    110131int AudioTestSvcStart(PATSSERVER pThis);

  • trunk/src/VBox/Devices/Audio/AudioTestServiceClient.cpp

    r89458 r89541  
    295295
    296296    /* For simplicity we always run on the same port, localhost only. */
    297     int rc = RTTcpClientConnect(pszAddr ? pszAddr : "127.0.0.1", uPort == 0 ? ATS_DEFAULT_PORT : uPort, &pClient->hSock);
     297    int rc = RTTcpClientConnect(pszAddr ? pszAddr : "127.0.0.1", uPort == 0 ? ATS_TCP_DEFAULT_PORT : uPort, &pClient->hSock);
    298298    if (RT_SUCCESS(rc))
    299299    {

  • trunk/src/VBox/Devices/Audio/AudioTestServiceInternal.h

    r89182 r89541  
    3333typedef PATSTRANSPORTCLIENT *PPATSTRANSPORTCLIENT;
    3434
     35/** Opaque ATS transport specific instance data. */
     36typedef struct ATSTRANSPORTINST *PATSTRANSPORTINST;
     37typedef PATSTRANSPORTINST *PPATSTRANSPORTINST;
     38
    3539/**
    3640 * Transport layer descriptor.
    … …  
    4246    /** The description. */
    4347    const char     *pszDesc;
    44     /** Pointer to an array of options. */
    45     PCRTGETOPTDEF   paOpts;
    46     /** The number of options in the array. */
    47     size_t          cOpts;
    48 
    49     /**
    50      * Print the usage information for this transport layer.
    51      *
    52      * @param   pStream             The stream to print the usage info to.
    53      *
    54      * @remarks This is only required if TXSTRANSPORT::cOpts is greater than 0.
    55      */
    56     DECLR3CALLBACKMEMBER(void, pfnUsage, (PRTSTREAM pStream));
    57 
    58     /**
    59      * Handle an option.
    60      *
    61      * When encountering an options that is not part of the base options, we'll call
    62      * this method for each transport layer until one handles it.
    63      *
    64      * @retval  VINF_SUCCESS if handled.
    65      * @retval  VERR_TRY_AGAIN if not handled.
    66      * @retval  VERR_INVALID_PARAMETER if we should exit with a non-zero status.
    67      *
    68      * @param   ch                  The short option value.
    69      * @param   pVal                Pointer to the value union.
    70      *
    71      * @remarks This is only required if TXSTRANSPORT::cOpts is greater than 0.
    72      */
    73     DECLR3CALLBACKMEMBER(int, pfnOption, (int ch, PCRTGETOPTUNION pVal));
    7448
    7549    /**
    … …  
    7852     * @returns IPRT status code.  On errors, the transport layer shall call
    7953     *          RTMsgError to display the error details to the user.
     54     * @param   pThis               The transport instance.
     55     * @param   pszBindAddr         Bind address. Empty means any address.
     56     * @param   uBindPort           Bind port. If set to 0, ATS_DEFAULT_PORT is being used.
    8057     */
    81     DECLR3CALLBACKMEMBER(int, pfnInit, (void));
     58    DECLR3CALLBACKMEMBER(int, pfnInit, (PATSTRANSPORTINST pThis, const char *pszBindAddr, uint32_t uBindPort));
    8259
    8360    /**
    … …  
    8663     * On errors, the transport layer shall call RTMsgError to display the error
    8764     * details to the user.
     65     *
     66     * @param   pThis               The transport instance.
    8867     */
    89     DECLR3CALLBACKMEMBER(void, pfnTerm, (void));
     68    DECLR3CALLBACKMEMBER(void, pfnTerm, (PATSTRANSPORTINST pThis));
    9069
    9170    /**
    … …  
    9372     * success.
    9473     */
    95     DECLR3CALLBACKMEMBER(int, pfnWaitForConnect, (PPATSTRANSPORTCLIENT ppClientNew));
     74    DECLR3CALLBACKMEMBER(int, pfnWaitForConnect, (PATSTRANSPORTINST pThis, PPATSTRANSPORTCLIENT ppClientNew));
    9675
    9776    /**
    … …  
    9978     *
    10079     * @returns true if there are pending packets, false if there isn't.
     80     * @param   pThis               The transport instance.
    10181     * @param   pClient             The client to poll for data.
    10282     */
    103     DECLR3CALLBACKMEMBER(bool, pfnPollIn, (PATSTRANSPORTCLIENT pClient));
     83    DECLR3CALLBACKMEMBER(bool, pfnPollIn, (PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient));
    10484
    10585    /**
    … …  
    10787     *
    10888     * @returns IPRT status code.
     89     * @param   pThis               The transport instance.
    10990     * @param   hPollSet            The poll set to add them to.
    11091     * @param   pClient             The transport client structure.
    11192     * @param   idStart             The handle ID to start at.
    11293     */
    113     DECLR3CALLBACKMEMBER(int, pfnPollSetAdd, (RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart));
     94    DECLR3CALLBACKMEMBER(int, pfnPollSetAdd, (PATSTRANSPORTINST pThis, RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart));
    11495
    11596    /**
    … …  
    11798     *
    11899     * @returns IPRT status code.
     100     * @param   pThis               The transport instance.
    119101     * @param   hPollSet            The poll set to remove from.
    120102     * @param   pClient             The transport client structure.
    121103     * @param   idStart             The handle ID to remove.
    122104     */
    123     DECLR3CALLBACKMEMBER(int, pfnPollSetRemove, (RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart));
     105    DECLR3CALLBACKMEMBER(int, pfnPollSetRemove, (PATSTRANSPORTINST pThis, RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart));
    124106
    125107    /**
    … …  
    134116     *          receive call.
    135117     *
     118     * @param   pThis               The transport instance.
    136119     * @param   pClient             The transport client structure.
    137120     * @param   ppPktHdr            Where to return the pointer to the packet we've
    … …  
    140123     *                              free by calling RTMemFree.
    141124     */
    142     DECLR3CALLBACKMEMBER(int, pfnRecvPkt, (PATSTRANSPORTCLIENT pClient, PPATSPKTHDR ppPktHdr));
     125    DECLR3CALLBACKMEMBER(int, pfnRecvPkt, (PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PPATSPKTHDR ppPktHdr));
    143126
    144127    /**
    … …  
    150133     * @retval  VERR_INTERRUPTED if interrupted before anything was sent.
    151134     *
     135     * @param   pThis               The transport instance.
    152136     * @param   pClient             The transport client structure.
    153137     * @param   pPktHdr             The packet to send.  The size is given by
    … …  
    155139     *                              ATSPKT_ALIGNMENT.
    156140     */
    157     DECLR3CALLBACKMEMBER(int, pfnSendPkt, (PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr));
     141    DECLR3CALLBACKMEMBER(int, pfnSendPkt, (PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr));
    158142
    159143    /**
    160144     * Sends a babble packet and disconnects the client (if applicable).
    161145     *
     146     * @param   pThis               The transport instance.
    162147     * @param   pClient             The transport client structure.
    163148     * @param   pPktHdr             The packet to send.  The size is given by
    … …  
    166151     * @param   cMsSendTimeout      The send timeout measured in milliseconds.
    167152     */
    168     DECLR3CALLBACKMEMBER(void, pfnBabble, (PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr, RTMSINTERVAL cMsSendTimeout));
     153    DECLR3CALLBACKMEMBER(void, pfnBabble, (PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr, RTMSINTERVAL cMsSendTimeout));
    169154
    170155    /**
    171156     * Notification about a client HOWDY.
    172157     *
     158     * @param   pThis               The transport instance.
    173159     * @param   pClient             The transport client structure.
    174160     */
    175     DECLR3CALLBACKMEMBER(void, pfnNotifyHowdy, (PATSTRANSPORTCLIENT pClient));
     161    DECLR3CALLBACKMEMBER(void, pfnNotifyHowdy, (PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient));
    176162
    177163    /**
    … …  
    181167     * client at this point.
    182168     *
     169     * @param   pThis               The transport instance.
    183170     * @param   pClient             The transport client structure.
    184171     */
    185     DECLR3CALLBACKMEMBER(void, pfnNotifyBye, (PATSTRANSPORTCLIENT pClient));
     172    DECLR3CALLBACKMEMBER(void, pfnNotifyBye, (PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient));
    186173
    187174    /**
    … …  
    190177     * For connection oriented transport layers, stop listening for and
    191178     * accepting at this point.
     179     *
     180     * @param   pThis               The transport instance.
    192181     */
    193     DECLR3CALLBACKMEMBER(void, pfnNotifyReboot, (void));
     182    DECLR3CALLBACKMEMBER(void, pfnNotifyReboot, (PATSTRANSPORTINST pThis));
    194183
    195184    /** Non-zero end marker. */

  • trunk/src/VBox/Devices/Audio/AudioTestServiceTcp.cpp

    r89204 r89541  
    3434#include <iprt/time.h>
    3535
     36#include "AudioTestService.h"
    3637#include "AudioTestServiceInternal.h"
    3738
    … …  
    4041*   Defined Constants And Macros                                                                                                 *
    4142*********************************************************************************************************************************/
    42 /** The default server port.
    43  *  Note: Do not choose/use 6042, as the Validation Kit TxsService already might use that port. */
    44 #define ATS_TCP_DEF_BIND_PORT                   6052
    45 /** The default server bind address. */
    46 #define ATS_TCP_DEF_BIND_ADDRESS                ""
    4743
    4844
    … …  
    7066*   Global Variables                                                                                                             *
    7167*********************************************************************************************************************************/
    72 /** @name TCP Parameters
    73  * @{ */
    74 /** The addresses to bind to.  Empty string means any.  */
    75 static char                 g_szTcpBindAddr[256]    = ATS_TCP_DEF_BIND_ADDRESS;
    76 /** The TCP port to listen to. */
    77 static uint32_t             g_uTcpBindPort          = ATS_TCP_DEF_BIND_PORT;
    78 /** @} */
    79 
    80 /** Pointer to the TCP server instance. */
    81 static PRTTCPSERVER         g_pTcpServer            = NULL;
    82 #if 0 /* unused */
    83 /** Stop connecting attempts when set. */
    84 static bool                 g_fTcpStopConnecting    = false;
    85 #endif
    86 
    87 
    8868
    8969/**
    9070 * Disconnects the current client and frees all stashed data.
    9171 */
    92 static void atsTcpDisconnectClient(PATSTRANSPORTCLIENT pClient)
    93 {
     72static void atsTcpDisconnectClient(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
     73{
     74    RT_NOREF(pThis);
     75
    9476    if (pClient->hTcpClient != NIL_RTSOCKET)
    9577    {
    … …  
    10991 * @interface_method_impl{ATSTRANSPORT,pfnWaitForConnect}
    11092 */
    111 static DECLCALLBACK(int) atsTcpWaitForConnect(PPATSTRANSPORTCLIENT ppClientNew)
     93static DECLCALLBACK(int) atsTcpWaitForConnect(PATSTRANSPORTINST pThis, PPATSTRANSPORTCLIENT ppClientNew)
    11294{
    11395    int rc;
    11496    RTSOCKET hClientNew;
    11597
    116     rc = RTTcpServerListen2(g_pTcpServer, &hClientNew);
     98    rc = RTTcpServerListen2(pThis->pTcpServer, &hClientNew);
    11799    Log(("atsTcpWaitForConnect: RTTcpServerListen2 -> %Rrc\n", rc));
    118100
    … …  
    141123 * @interface_method_impl{ATSTRANSPORT,pfnNotifyReboot}
    142124 */
    143 static DECLCALLBACK(void) atsTcpNotifyReboot(void)
    144 {
    145     Log(("atsTcpNotifyReboot: RTTcpServerDestroy(%p)\n", g_pTcpServer));
    146     if (g_pTcpServer)
    147     {
    148         int rc = RTTcpServerDestroy(g_pTcpServer);
     125static DECLCALLBACK(void) atsTcpNotifyReboot(PATSTRANSPORTINST pThis)
     126{
     127    Log(("atsTcpNotifyReboot: RTTcpServerDestroy(%p)\n", pThis->pTcpServer));
     128    if (pThis->pTcpServer)
     129    {
     130        int rc = RTTcpServerDestroy(pThis->pTcpServer);
    149131        if (RT_FAILURE(rc))
    150132            RTMsgInfo("RTTcpServerDestroy failed in atsTcpNotifyReboot: %Rrc", rc);
    151         g_pTcpServer = NULL;
     133        pThis->pTcpServer = NULL;
    152134    }
    153135}
    … …  
    156138 * @interface_method_impl{ATSTRANSPORT,pfnNotifyBye}
    157139 */
    158 static DECLCALLBACK(void) atsTcpNotifyBye(PATSTRANSPORTCLIENT pClient)
     140static DECLCALLBACK(void) atsTcpNotifyBye(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
    159141{
    160142    Log(("atsTcpNotifyBye: atsTcpDisconnectClient %RTsock\n", pClient->hTcpClient));
    161     atsTcpDisconnectClient(pClient);
     143    atsTcpDisconnectClient(pThis, pClient);
    162144    RTMemFree(pClient);
    163145}
    … …  
    166148 * @interface_method_impl{ATSTRANSPORT,pfnNotifyHowdy}
    167149 */
    168 static DECLCALLBACK(void) atsTcpNotifyHowdy(PATSTRANSPORTCLIENT pClient)
     150static DECLCALLBACK(void) atsTcpNotifyHowdy(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
    169151{
    170152    /* nothing to do here */
    171     RT_NOREF1(pClient);
     153    RT_NOREF(pThis, pClient);
    172154}
    173155
    … …  
    175157 * @interface_method_impl{ATSTRANSPORT,pfnBabble}
    176158 */
    177 static DECLCALLBACK(void) atsTcpBabble(PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr, RTMSINTERVAL cMsSendTimeout)
     159static DECLCALLBACK(void) atsTcpBabble(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr, RTMSINTERVAL cMsSendTimeout)
    178160{
    179161    /*
    … …  
    190172     */
    191173    Log(("atsTcpBabble: atsTcpDisconnectClient(%RTsock) (RTTcpWrite rc=%Rrc)\n", pClient->hTcpClient, rc));
    192     atsTcpDisconnectClient(pClient);
     174    atsTcpDisconnectClient(pThis, pClient);
    193175}
    194176
    … …  
    196178 * @interface_method_impl{ATSTRANSPORT,pfnSendPkt}
    197179 */
    198 static DECLCALLBACK(int) atsTcpSendPkt(PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr)
     180static DECLCALLBACK(int) atsTcpSendPkt(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr)
    199181{
    200182    Assert(pPktHdr->cb >= sizeof(ATSPKTHDR));
    … …  
    210192        /* assume fatal connection error. */
    211193        Log(("RTTcpWrite -> %Rrc -> atsTcpDisconnectClient(%RTsock)\n", rc, pClient->hTcpClient));
    212         atsTcpDisconnectClient(pClient);
     194        atsTcpDisconnectClient(pThis, pClient);
    213195    }
    214196
    … …  
    219201 * @interface_method_impl{ATSTRANSPORT,pfnRecvPkt}
    220202 */
    221 static DECLCALLBACK(int) atsTcpRecvPkt(PATSTRANSPORTCLIENT pClient, PPATSPKTHDR ppPktHdr)
     203static DECLCALLBACK(int) atsTcpRecvPkt(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PPATSPKTHDR ppPktHdr)
    222204{
    223205    int rc = VINF_SUCCESS;
    … …  
    335317            /* assume fatal connection error. */
    336318            Log(("atsTcpRecvPkt: RTTcpRead -> %Rrc -> atsTcpDisconnectClient(%RTsock)\n", rc, pClient->hTcpClient));
    337             atsTcpDisconnectClient(pClient);
     319            atsTcpDisconnectClient(pThis, pClient);
    338320        }
    339321    }
    … …  
    345327 * @interface_method_impl{ATSTRANSPORT,pfnPollSetAdd}
    346328 */
    347 static DECLCALLBACK(int) atsTcpPollSetAdd(RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart)
    348 {
     329static DECLCALLBACK(int) atsTcpPollSetAdd(PATSTRANSPORTINST pThis, RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart)
     330{
     331    RT_NOREF(pThis);
    349332    return RTPollSetAddSocket(hPollSet, pClient->hTcpClient, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, idStart);
    350333}
    … …  
    353336 * @interface_method_impl{ATSTRANSPORT,pfnPollSetRemove}
    354337 */
    355 static DECLCALLBACK(int) atsTcpPollSetRemove(RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart)
    356 {
    357     RT_NOREF1(pClient);
     338static DECLCALLBACK(int) atsTcpPollSetRemove(PATSTRANSPORTINST pThis, RTPOLLSET hPollSet, PATSTRANSPORTCLIENT pClient, uint32_t idStart)
     339{
     340    RT_NOREF(pThis, pClient);
    358341    return RTPollSetRemove(hPollSet, idStart);
    359342}
    … …  
    362345 * @interface_method_impl{ATSTRANSPORT,pfnPollIn}
    363346 */
    364 static DECLCALLBACK(bool) atsTcpPollIn(PATSTRANSPORTCLIENT pClient)
    365 {
     347static DECLCALLBACK(bool) atsTcpPollIn(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
     348{
     349    RT_NOREF(pThis);
    366350    int rc = RTTcpSelectOne(pClient->hTcpClient, 0/*cMillies*/);
    367351    return RT_SUCCESS(rc);
    … …  
    371355 * @interface_method_impl{ATSTRANSPORT,pfnTerm}
    372356 */
    373 static DECLCALLBACK(void) atsTcpTerm(void)
     357static DECLCALLBACK(void) atsTcpTerm(PATSTRANSPORTINST pThis)
    374358{
    375359    /* Shut down the server (will wake up thread). */
    376     if (g_pTcpServer)
     360    if (pThis->pTcpServer)
    377361    {
    378362        Log(("atsTcpTerm: Destroying server...\n"));
    379         int rc = RTTcpServerDestroy(g_pTcpServer);
     363        int rc = RTTcpServerDestroy(pThis->pTcpServer);
    380364        if (RT_FAILURE(rc))
    381365            RTMsgInfo("RTTcpServerDestroy failed in atsTcpTerm: %Rrc", rc);
    382         g_pTcpServer        = NULL;
     366        pThis->pTcpServer        = NULL;
    383367    }
    384368
    … …  
    389373 * @interface_method_impl{ATSTRANSPORT,pfnInit}
    390374 */
    391 static DECLCALLBACK(int) atsTcpInit(void)
    392 {
    393     int rc = RTTcpServerCreateEx(g_szTcpBindAddr[0] ? g_szTcpBindAddr : NULL, g_uTcpBindPort, &g_pTcpServer);
     375static DECLCALLBACK(int) atsTcpInit(PATSTRANSPORTINST pThis, const char *pszBindAddr, uint32_t uBindPort)
     376{
     377    int rc = RTTcpServerCreateEx(pszBindAddr[0] ? pszBindAddr : NULL, uBindPort, &pThis->pTcpServer);
    394378    if (RT_FAILURE(rc))
    395379    {
    … …  
    397381        {
    398382            RTMsgInfo("RTTcpServerCreateEx(%s, %u,) failed: %Rrc, retrying for 20 seconds...\n",
    399                       g_szTcpBindAddr[0] ? g_szTcpBindAddr : NULL, g_uTcpBindPort, rc);
     383                      pszBindAddr[0] ? pszBindAddr : NULL, uBindPort, rc);
    400384            uint64_t StartMs = RTTimeMilliTS();
    401385            do
    402386            {
    403387                RTThreadSleep(1000);
    404                 rc = RTTcpServerCreateEx(g_szTcpBindAddr[0] ? g_szTcpBindAddr : NULL, g_uTcpBindPort, &g_pTcpServer);
     388                rc = RTTcpServerCreateEx(pszBindAddr[0] ? pszBindAddr : NULL, uBindPort, &pThis->pTcpServer);
    405389            } while (   rc == VERR_NET_DOWN
    406390                     && RTTimeMilliTS() - StartMs < 20000);
    … …  
    410394        if (RT_FAILURE(rc))
    411395        {
    412             g_pTcpServer = NULL;
     396            pThis->pTcpServer = NULL;
    413397            RTMsgError("RTTcpServerCreateEx(%s, %u,) failed: %Rrc\n",
    414                        g_szTcpBindAddr[0] ? g_szTcpBindAddr : NULL, g_uTcpBindPort, rc);
     398                       pszBindAddr[0] ? pszBindAddr : NULL, uBindPort, rc);
    415399        }
    416400    }
    … …  
    418402    return rc;
    419403}
    420 
    421 /** Options  */
    422 enum ATSTCPOPT
    423 {
    424     ATSTCPOPT_BIND_ADDRESS = 1000,
    425     ATSTCPOPT_BIND_PORT
    426 };
    427 
    428 /**
    429  * @interface_method_impl{ATSTRANSPORT,pfnOption}
    430  */
    431 static DECLCALLBACK(int) atsTcpOption(int ch, PCRTGETOPTUNION pVal)
    432 {
    433     int rc;
    434 
    435     switch (ch)
    436     {
    437         case ATSTCPOPT_BIND_ADDRESS:
    438             rc = RTStrCopy(g_szTcpBindAddr, sizeof(g_szTcpBindAddr), pVal->psz);
    439             if (RT_FAILURE(rc))
    440                 return RTMsgErrorRc(VERR_INVALID_PARAMETER, "TCP bind address is too long (%Rrc)", rc);
    441             return VINF_SUCCESS;
    442 
    443         case ATSTCPOPT_BIND_PORT:
    444             g_uTcpBindPort = pVal->u16 == 0 ? ATS_TCP_DEF_BIND_PORT : pVal->u16;
    445             return VINF_SUCCESS;
    446     }
    447     return VERR_TRY_AGAIN;
    448 }
    449 
    450 /**
    451  * @interface_method_impl{ATSTRANSPORT,pfnUsage}
    452  */
    453 DECLCALLBACK(void) atsTcpUsage(PRTSTREAM pStream)
    454 {
    455     RTStrmPrintf(pStream,
    456                  "  --tcp-bind-address <address>\n"
    457                  "       The address(es) to listen to TCP connection on.  Empty string\n"
    458                  "       means any address, this is the default.\n"
    459                  "  --tcp-bind-port <port>\n"
    460                  "       The port to listen to TCP connections on.\n"
    461                  "       Default: %u\n"
    462                  , ATS_TCP_DEF_BIND_PORT);
    463 }
    464 
    465 /** Command line options for the TCP/IP transport layer. */
    466 static const RTGETOPTDEF  g_TcpOpts[] =
    467 {
    468     { "--tcp-bind-address",     ATSTCPOPT_BIND_ADDRESS,     RTGETOPT_REQ_STRING },
    469     { "--tcp-bind-port",        ATSTCPOPT_BIND_PORT,        RTGETOPT_REQ_UINT16 }
    470 };
    471404
    472405/** TCP/IP transport layer. */
    … …  
    475408    /* .szName            = */ "tcp",
    476409    /* .pszDesc           = */ "TCP/IP",
    477     /* .cOpts             = */ &g_TcpOpts[0],
    478     /* .paOpts            = */ RT_ELEMENTS(g_TcpOpts),
    479     /* .pfnUsage          = */ atsTcpUsage,
    480     /* .pfnOption         = */ atsTcpOption,
    481410    /* .pfnInit           = */ atsTcpInit,
    482411    /* .pfnTerm           = */ atsTcpTerm,
    … …  
    493422    /* .u32EndMarker      = */ UINT32_C(0x12345678)
    494423};
     424

  • trunk/src/VBox/Devices/Audio/DrvHostAudioValidationKit.cpp

    r89510 r89541  
    155155    pTst->pObj = NULL;
    156156
    157     AssertPtrReturnVoid(pTst->pEntry);
    158     AudioTestSetTestDone(pTst->pEntry);
    159     pTst->pEntry = NULL;
     157    if (pTst->pEntry) /* Set set entry assign? Mark as done. */
     158    {
     159        AssertPtrReturnVoid(pTst->pEntry);
     160        AudioTestSetTestDone(pTst->pEntry);
     161        pTst->pEntry = NULL;
     162    }
    160163
    161164    RTMemFree(pTst);
    … …  
    235238/** @copydoc ATSCALLBACKS::pfnTonePlay
    236239 *
    237  * Creates and registers a new test tone recording test
    238  * which later then gets recorded by the guest side.
     240 * Creates and registers a new test tone guest recording test.
    239241 */
    240242static DECLCALLBACK(int) drvHostValKitRegisterGuestRecTest(void const *pvUser, PAUDIOTESTTONEPARMS pToneParms)
    … …  
    270272/** @copydoc ATSCALLBACKS::pfnToneRecord
    271273 *
    272  * Creates and registers a new test tone playback test
    273  * which later then records audio played back by the guest side.
     274 * Creates and registers a new test tone guest playback test.
    274275 */
    275276static DECLCALLBACK(int) drvHostValKitRegisterGuestPlayTest(void const *pvUser, PAUDIOTESTTONEPARMS pToneParms)
    … …  
    283284
    284285    pTestData->t.TestTone.u.Rec.cbToWrite = PDMAudioPropsMilliToBytes(&pToneParms->Props,
    285                                                                 pTestData->t.TestTone.Parms.msDuration);
     286                                                                      pTestData->t.TestTone.Parms.msDuration);
    286287    int rc = RTCritSectEnter(&pThis->CritSect);
    287288    if (RT_SUCCESS(rc))
    … …  
    714715    Callbacks.pvUser          = pThis;
    715716
    716     LogRel(("Audio: Validation Kit: Starting Audio Test Service (ATS) ...\n"));
    717 
    718     int rc = AudioTestSvcInit(&pThis->Srv, &Callbacks);
     717    /** @todo Make this configurable via CFGM. */
     718    const char *pszTcpAddr = "127.0.0.1";
     719       uint32_t uTcpPort   = ATS_TCP_DEFAULT_PORT;
     720
     721    LogRel(("Audio: Validation Kit: Starting Audio Test Service (ATS) at %s:%RU32...\n",
     722            pszTcpAddr, uTcpPort));
     723
     724    int rc = AudioTestSvcInit(&pThis->Srv,
     725                              /* We only allow connections from localhost for now. */
     726                              pszTcpAddr, uTcpPort, &Callbacks);
    719727    if (RT_SUCCESS(rc))
    720728        rc = AudioTestSvcStart(&pThis->Srv);

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

    r89525 r89541  
    182182    /** Audio testing mode. */
    183183    AUDIOTESTMODE           enmMode;
     184    /** Whether self test mode is active or not. */
     185    bool                    fSelftest;
    184186    /** Output path for storing the test environment's final test files. */
    185187    char                    szTag[AUDIOTEST_TAG_MAX];
    … …  
    211213        struct
    212214        {
    213             ATSCLIENT       Client;
     215            /** Client connected to the ATS on the guest side. */
     216            ATSCLIENT       AtsClGuest;
     217            /** Client connected to the ATS on the Validation Kit. */
     218            ATSCLIENT       AtsClValKit;
    214219        } Host;
    215220    } u;
    … …  
    303308enum
    304309{
    305     VKAT_SELFTEST_OPT_ATS_HOST = 900
     310    VKAT_SELFTEST_OPT_ATS_GUEST_ADDR = 900,
     311    VKAT_SELFTEST_OPT_ATS_GUEST_PORT,
     312    VKAT_SELFTEST_OPT_ATS_VALKIT_ADDR,
     313    VKAT_SELFTEST_OPT_ATS_VALKIT_PORT
    306314};
    307315
    … …  
    493501                RTThreadSleep(pTstEnv->cMsSchedulingHint);
    494502
    495                 RTTestPrintf(g_hTest, RTTESTLVL_DEBUG,  "Written %RU32 bytes\n", cbWritten);
    496 
    497503                Assert(cbToWrite >= cbWritten);
    498504                cbToWrite -= cbWritten;
    … …  
    564570                RTThreadSleep(pTstEnv->cMsSchedulingHint);
    565571
    566                 RTTestPrintf(g_hTest, RTTESTLVL_DEBUG,  "Read %RU32 bytes\n", cbRead);
    567 
    568572                Assert(cbToRead >= cbRead);
    569573                cbToRead -= cbRead;
    … …  
    595599    PAUDIOTESTENV   pTstEnv = pCtx->pTstEnv;
    596600
    597     RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Beginning test set '%s'\n", pszTag);
    598 
    599     return AudioTestSetCreate(&pTstEnv->Set, pTstEnv->szPathTemp, pszTag);
     601    char szTag[AUDIOTEST_TAG_MAX];
     602    int rc = RTStrPrintf2(szTag, sizeof(szTag), "%s-guest", pszTag);
     603    AssertRCReturn(rc, rc);
     604
     605    RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Beginning test set '%s'\n", szTag);
     606
     607    return AudioTestSetCreate(&pTstEnv->Set, pTstEnv->szPathTemp, szTag);
    600608}
    601609
    … …  
    708716 * @param   pDrvReg             Audio driver to use.
    709717 * @param   fWithDrvAudio       Whether to include DrvAudio in the stack or not.
    710  * @param   pszTag              Tag name to use. If NULL, a generated UUID will be used.
    711718 * @param   pszTcpAddr          TCP/IP address to connect to.
     719 *                              If NULL, localhost (127.0.0.1) will be used.
    712720 * @param   uTcpPort            TCP/IP port to connect to.
     721 *                              If 0, ATS_DEFAULT_PORT will be used.
    713722 */
    714723static int audioTestEnvInit(PAUDIOTESTENV pTstEnv,
    715                             PCPDMDRVREG pDrvReg, bool fWithDrvAudio, const char *pszTag,
     724                            PCPDMDRVREG pDrvReg, bool fWithDrvAudio,
    716725                            const char *pszTcpAddr, uint32_t uTcpPort)
    717726{
    718727    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test mode is '%s'\n", pTstEnv->enmMode == AUDIOTESTMODE_HOST ? "host" : "guest");
    719     RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Using tag '%s'\n", pszTag);
     728    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Using tag '%s'\n", pTstEnv->szTag);
    720729    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Output directory is '%s'\n", pTstEnv->szPathOut);
    721730    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Temp directory is '%s'\n", pTstEnv->szPathTemp);
    … …  
    730739
    731740    /* Only the guest mode needs initializing the driver stack. */
    732     const bool fUseDriverStack = pTstEnv->enmMode == AUDIOTESTMODE_GUEST;
     741    const bool fUseDriverStack =    pTstEnv->enmMode == AUDIOTESTMODE_GUEST
     742                                 /* The self test mode drives the ValKit audio driver locally,
     743                                  * so also use the driver stack here. */
     744                                 || pTstEnv->fSelftest;
    733745    if (fUseDriverStack)
    734746    {
    … …  
    772784        Callbacks.pvUser          = &Ctx;
    773785
    774         RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Starting ATS ...\n");
    775         rc = AudioTestSvcInit(&pTstEnv->u.Guest.Srv, &Callbacks);
     786        RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Starting guest ATS at %s:%RU32...\n", pszTcpAddr, uTcpPort);
     787        rc = AudioTestSvcInit(&pTstEnv->u.Guest.Srv, pszTcpAddr, uTcpPort, &Callbacks);
    776788        if (RT_SUCCESS(rc))
    777789            rc = AudioTestSvcStart(&pTstEnv->u.Guest.Srv);
    … …  
    785797    else /* Host mode */
    786798    {
    787         RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Connecting to ATS at %s:%RU32 ...\n", pszTcpAddr, uTcpPort);
    788 
    789         rc = AudioTestSvcClientConnect(&pTstEnv->u.Host.Client, pszTcpAddr, uTcpPort);
     799        RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Connecting to guest ATS at %s:%RU32 ...\n",
     800                     (pszTcpAddr && *pszTcpAddr) ? pszTcpAddr : "127.0.0.1", uTcpPort ? uTcpPort : ATS_TCP_DEFAULT_PORT);
     801
     802        rc = AudioTestSvcClientConnect(&pTstEnv->u.Host.AtsClGuest, pszTcpAddr, uTcpPort);
    790803        if (RT_FAILURE(rc))
    791804        {
    … …  
    850863    AudioTestSetDestroy(&pTstEnv->Set);
    851864
     865    if (RT_FAILURE(rc))
     866        RTTestFailed(g_hTest, "Test set prologue failed with %Rrc\n", rc);
     867
    852868    return rc;
    853869}
    … …  
    892908static int audioTestDevicesEnumerateAndCheck(PAUDIOTESTENV pTstEnv, const char *pszDev, PPDMAUDIOHOSTDEV *ppDev)
    893909{
     910#ifdef DEBUG_andy
     911    return VINF_SUCCESS;
     912#endif
     913
    894914    RTTestSubF(g_hTest, "Enumerating audio devices and checking for device '%s'", pszDev ? pszDev : "<Default>");
    895915
    … …  
    11071127            Cfg.Props = pTstParms->Props;
    11081128
    1109             rc = AudioTestSvcClientTonePlay(&pTstEnv->u.Host.Client, &pTstParms->TestTone);
     1129            rc = AudioTestSvcClientTonePlay(&pTstEnv->u.Host.AtsClGuest, &pTstParms->TestTone);
    11101130            if (RT_SUCCESS(rc))
    11111131            {
    … …  
    11381158static DECLCALLBACK(int) audioTestRecordToneSetup(PAUDIOTESTENV pTstEnv, PAUDIOTESTDESC pTstDesc, PAUDIOTESTPARMS pTstParmsAcq, void **ppvCtx)
    11391159{
    1140     RT_NOREF(pTstEnv, pTstDesc, ppvCtx);
     1160    RT_NOREF(pTstDesc, ppvCtx);
    11411161
    11421162    pTstParmsAcq->enmType     = AUDIOTESTTYPE_TESTTONE_RECORD;
    … …  
    11521172    pTstParmsAcq->idxCurrent  = 0;
    11531173
    1154     return VINF_SUCCESS;
     1174    /* Connect to the Validation Kit audio driver ATS. */
     1175    int rc = AudioTestSvcClientConnect(&pTstEnv->u.Host.AtsClValKit,
     1176                                       "127.0.0.1" /** @todo Make this dynamic. */, ATS_TCP_DEFAULT_PORT);
     1177    if (RT_SUCCESS(rc))
     1178    {
     1179        char szTag[AUDIOTEST_TAG_MAX];
     1180        rc = RTStrPrintf2(szTag, sizeof(szTag), "%s-valkit", pTstEnv->szTag);
     1181        if (RT_SUCCESS(rc))
     1182            rc = AudioTestSvcClientTestSetBegin(&pTstEnv->u.Host.AtsClValKit, szTag);
     1183    }
     1184
     1185    return rc;
    11551186}
    11561187
    … …  
    11671198    {
    11681199        pTstParms->TestTone.Props      = pTstParms->Props;
    1169         pTstParms->TestTone.msDuration = RTRandU32Ex(50 /* ms */, RT_MS_10SEC); /** @todo Record even longer? */
    1170 
     1200#ifdef DEBUG_andy
     1201        pTstParms->TestTone.msDuration = RTRandU32Ex(50 /* ms */, 2000);
     1202#else
     1203        pTstParms->TestTone.msDuration = RTRandU32Ex(50 /* ms */, RT_MS_30SEC); /** @todo Record even longer? */
     1204#endif
    11711205        PAUDIOTESTENTRY pTst;
    11721206        rc = AudioTestSetTestBegin(&pTstEnv->Set, "Recording test tone", pTstParms, &pTst);
    11731207        if (RT_SUCCESS(rc))
    11741208        {
    1175             rc = AudioTestSvcClientToneRecord(&pTstEnv->u.Host.Client, &pTstParms->TestTone);
     1209            /*
     1210             * 1. Arm the ValKit ATS with the recording parameters.
     1211             */
     1212            rc = AudioTestSvcClientTonePlay(&pTstEnv->u.Host.AtsClValKit, &pTstParms->TestTone);
    11761213            if (RT_SUCCESS(rc))
    11771214            {
    1178                 AudioTestSetTestDone(pTst);
     1215                /*
     1216                 * 2. Tell the guest ATS to start recording.
     1217                 */
     1218                rc = AudioTestSvcClientToneRecord(&pTstEnv->u.Host.AtsClGuest, &pTstParms->TestTone);
     1219                if (RT_SUCCESS(rc))
     1220                {
     1221                    AudioTestSetTestDone(pTst);
     1222                }
     1223                else
     1224                    AudioTestSetTestFailed(pTst, rc, "Recording test tone failed");
    11791225            }
    1180             else
    1181                 AudioTestSetTestFailed(pTst, rc, "Recording test tone failed");
    11821226        }
    11831227
    … …  
    11941238static DECLCALLBACK(int) audioTestRecordToneDestroy(PAUDIOTESTENV pTstEnv, void *pvCtx)
    11951239{
    1196     RT_NOREF(pTstEnv, pvCtx);
    1197 
    1198     return VINF_SUCCESS;
     1240    RT_NOREF(pvCtx);
     1241
     1242    char szTag[AUDIOTEST_TAG_MAX];
     1243    int rc = RTStrPrintf2(szTag, sizeof(szTag), "%s-valkit", pTstEnv->szTag);
     1244    if (RT_SUCCESS(rc))
     1245        rc = AudioTestSvcClientTestSetEnd(&pTstEnv->u.Host.AtsClValKit, szTag);
     1246
     1247    int rc2 = AudioTestSvcClientClose(&pTstEnv->u.Host.AtsClValKit);
     1248    if (RT_SUCCESS(rc))
     1249        rc = rc2;
     1250
     1251    return rc;
    11991252}
    12001253
    … …  
    12451298        if (RT_FAILURE(rc))
    12461299        {
    1247             RTTestFailed(g_hTest, "Test setup failed\n");
     1300            RTTestFailed(g_hTest, "Test setup failed with %Rrc\n", rc);
    12481301            return rc;
    12491302        }
    … …  
    12591312    AssertPtr(pTstDesc->pfnExec);
    12601313    rc = pTstDesc->pfnExec(pTstEnv, pvCtx, &TstParms);
     1314    if (RT_FAILURE(rc))
     1315        RTTestFailed(g_hTest, "Test failed with %Rrc\n", rc);
    12611316
    12621317    RTTestSubDone(g_hTest);
    … …  
    12691324
    12701325        if (RT_FAILURE(rc2))
    1271             RTTestFailed(g_hTest, "Test destruction failed\n");
     1326            RTTestFailed(g_hTest, "Test destruction failed with %Rrc\n", rc2);
    12721327    }
    12731328
    … …  
    12921347    if (pTstEnv->enmMode == AUDIOTESTMODE_GUEST)
    12931348    {
    1294         RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "ATS running\n");
    1295 
    1296         while (!g_fTerminate) /** @todo Implement signal handling. */
    1297         {
     1349        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Guest ATS running\n");
     1350
     1351        while (!g_fTerminate)
    12981352            RTThreadSleep(100);
    1299         }
    1300 
    1301         RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Shutting down ATS ...\n");
     1353
     1354        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Shutting down guest ATS ...\n");
    13021355
    13031356        int rc2 = AudioTestSvcShutdown(&pTstEnv->u.Guest.Srv);
    13041357        if (RT_SUCCESS(rc))
    13051358            rc = rc2;
     1359
     1360        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Guest ATS shutdown complete\n");
    13061361    }
    13071362    else if (pTstEnv->enmMode == AUDIOTESTMODE_HOST)
    13081363    {
     1364        /* Generate tag for the host side. */
     1365        char szTag[AUDIOTEST_TAG_MAX];
     1366        rc = RTStrPrintf2(szTag, sizeof(szTag), "%s-host", pTstEnv->szTag);
     1367        AssertRCReturn(rc, rc);
     1368
    13091369        /* We have one single test set for all executed tests for now. */
    1310         rc = AudioTestSetCreate(&pTstEnv->Set, pTstEnv->szPathTemp, pTstEnv->szTag);
     1370        rc = AudioTestSetCreate(&pTstEnv->Set, pTstEnv->szPathTemp, szTag);
    13111371        if (RT_SUCCESS(rc))
    13121372        {
    1313             /* Copy back the (eventually generated) tag to the test environment. */
    1314             rc = RTStrCopy(pTstEnv->szTag, sizeof(pTstEnv->szTag), AudioTestSetGetTag(&pTstEnv->Set));
    1315             AssertRC(rc);
    1316 
    1317             rc = AudioTestSvcClientTestSetBegin(&pTstEnv->u.Host.Client, pTstEnv->szTag);
     1373            rc = AudioTestSvcClientTestSetBegin(&pTstEnv->u.Host.AtsClGuest, pTstEnv->szTag);
    13181374            if (RT_SUCCESS(rc))
    13191375            {
    … …  
    13271383                    if (!g_aTests[i].fExcluded)
    13281384                        uSeq++;
     1385
     1386                    if (g_fTerminate)
     1387                        break;
    13291388                }
    13301389
    1331                 int rc2 = AudioTestSvcClientTestSetEnd(&pTstEnv->u.Host.Client, pTstEnv->szTag);
     1390                int rc2 = AudioTestSvcClientTestSetEnd(&pTstEnv->u.Host.AtsClGuest, pTstEnv->szTag);
    13321391                if (RT_SUCCESS(rc))
    13331392                    rc = rc2;
    … …  
    15091568        /* Use the default port is none is specified. */
    15101569        if (!uTcpPort)
    1511             uTcpPort = ATS_DEFAULT_PORT;
     1570            uTcpPort = ATS_TCP_DEFAULT_PORT;
    15121571
    15131572        if (!pszTcpAddr)
    … …  
    15161575
    15171576    /* For now all tests have the same test environment. */
    1518     rc = audioTestEnvInit(&TstEnv, pDrvReg, fWithDrvAudio, pszTag, pszTcpAddr, uTcpPort);
     1577    rc = audioTestEnvInit(&TstEnv, pDrvReg, fWithDrvAudio, pszTcpAddr, uTcpPort);
    15191578    if (RT_SUCCESS(rc))
    15201579    {
    … …  
    15261585
    15271586    if (RT_FAILURE(rc)) /* Let us know that something went wrong in case we forgot to mention it. */
    1528         RTTestFailed(g_hTest, "Tested failed with %Rrc\n", rc);
     1587        RTTestFailed(g_hTest, "Testing failed with %Rrc\n", rc);
    15291588
    15301589    /*
    … …  
    24812540*********************************************************************************************************************************/
    24822541
     2542/** @todo Move this (all?) commands into separate files -- this file is too big already. */
     2543
    24832544/**
    24842545 * Command line parameters for self-test mode.
    … …  
    24862547static const RTGETOPTDEF g_aCmdSelftestOptions[] =
    24872548{
    2488     { "--ats-host",         VKAT_SELFTEST_OPT_ATS_HOST,   RTGETOPT_REQ_STRING },
    2489     { "--backend",          'b',                          RTGETOPT_REQ_STRING  },
    2490     { "--with-drv-audio",   'd',                          RTGETOPT_REQ_NOTHING },
     2549    { "--ats-guest-addr",   VKAT_SELFTEST_OPT_ATS_GUEST_ADDR,   RTGETOPT_REQ_STRING  },
     2550    { "--ats-guest-port",   VKAT_SELFTEST_OPT_ATS_GUEST_PORT,   RTGETOPT_REQ_UINT32  },
     2551    { "--ats-valkit-addr",  VKAT_SELFTEST_OPT_ATS_GUEST_ADDR,   RTGETOPT_REQ_STRING  },
     2552    { "--ats-valkit-port",  VKAT_SELFTEST_OPT_ATS_GUEST_PORT,   RTGETOPT_REQ_UINT32  },
     2553    { "--exclude-all",      'a',                                RTGETOPT_REQ_NOTHING },
     2554    { "--backend",          'b',                                RTGETOPT_REQ_STRING  },
     2555    { "--with-drv-audio",   'd',                                RTGETOPT_REQ_NOTHING },
     2556    { "--exclude",          'e',                                RTGETOPT_REQ_UINT32  },
     2557    { "--include",          'i',                                RTGETOPT_REQ_UINT32  }
    24912558};
    24922559
    … …  
    25032570
    25042571/**
    2505  * Tests the Audio Test Service (ATS).
     2572 * Structure for keeping a VKAT self test context.
     2573 */
     2574typedef struct SELFTESTCTX
     2575{
     2576    /** Common tag for guest and host side. */
     2577    char             szTag[AUDIOTEST_TAG_MAX];
     2578    /** Whether to use DrvAudio in the driver stack or not. */
     2579    bool             fWithDrvAudio;
     2580    struct
     2581    {
     2582        AUDIOTESTENV TstEnv;
     2583        /** Audio driver to use.
     2584         *  Defaults to the platform's default driver. */
     2585        PCPDMDRVREG  pDrvReg;
     2586    } Guest;
     2587    struct
     2588    {
     2589        AUDIOTESTENV TstEnv;
     2590        /** Address of the guest ATS instance.
     2591         *  Defaults to localhost (127.0.0.1) if not set. */
     2592        char         szGuestAtsAddr[64];
     2593        /** Port of the guest ATS instance.
     2594         *  Defaults to ATS_DEFAULT_PORT if not set. */
     2595        uint32_t     uGuestAtsPort;
     2596        /** Address of the Validation Kit audio driver ATS instance.
     2597         *  Defaults to localhost (127.0.0.1) if not set. */
     2598        char         szValKitAtsAddr[64];
     2599        /** Port of the Validation Kit audio driver ATS instance.
     2600         *  Defaults to ATS_ALT_PORT if not set. */
     2601        uint32_t     uValKitAtsPort;
     2602    } Host;
     2603} SELFTESTCTX;
     2604/** Pointer to a VKAT self test context. */
     2605typedef SELFTESTCTX *PSELFTESTCTX;
     2606
     2607static DECLCALLBACK(int) audioTestSelftestGuestAtsThread(RTTHREAD hThread, void *pvUser)
     2608{
     2609    RT_NOREF(hThread);
     2610    PSELFTESTCTX pCtx = (PSELFTESTCTX)pvUser;
     2611
     2612    AUDIOTESTPARMS TstCust;
     2613    audioTestParmsInit(&TstCust);
     2614
     2615    PAUDIOTESTENV pTstEnv = &pCtx->Guest.TstEnv;
     2616
     2617    /* Flag the environment for self test mode. */
     2618    pTstEnv->fSelftest = true;
     2619
     2620    /* Generate tag for guest side. */
     2621    int rc = RTStrCopy(pTstEnv->szTag, sizeof(pTstEnv->szTag), pCtx->szTag);
     2622    AssertRCReturn(rc, rc);
     2623
     2624    rc = AudioTestPathCreateTemp(pTstEnv->szPathTemp, sizeof(pTstEnv->szPathTemp), "selftest-guest");
     2625    AssertRCReturn(rc, rc);
     2626
     2627    rc = AudioTestPathCreateTemp(pTstEnv->szPathOut, sizeof(pTstEnv->szPathOut), "selftest-out");
     2628    AssertRCReturn(rc, rc);
     2629
     2630    pTstEnv->enmMode = AUDIOTESTMODE_GUEST;
     2631
     2632    /** @todo Make this customizable. */
     2633    PDMAudioPropsInit(&TstCust.TestTone.Props,
     2634                      2 /* 16-bit */, true  /* fSigned */, 2 /* cChannels */, 44100 /* uHz */);
     2635
     2636    /* Use ATS_ALT_PORT, as on ATS_DEFAULT_PORT the
     2637     * Validation Kit audio driver ATS already is running on ATS_DEFAULT_PORT. */
     2638    rc = audioTestEnvInit(pTstEnv, pCtx->Guest.pDrvReg, pCtx->fWithDrvAudio,
     2639                          "127.0.0.1", ATS_TCP_ALT_PORT);
     2640    if (RT_SUCCESS(rc))
     2641    {
     2642        RTThreadUserSignal(hThread);
     2643
     2644        audioTestWorker(pTstEnv, &TstCust);
     2645        audioTestEnvDestroy(pTstEnv);
     2646    }
     2647
     2648    audioTestParmsDestroy(&TstCust);
     2649
     2650    return rc;
     2651}
     2652
     2653/**
     2654 * Main function for performing the self test.
    25062655 *
    25072656 * @returns VBox status code.
    2508  * @param   pDrvReg             Backend driver to use.
    2509  * @param   pszAdr              Address of ATS server to connect to.
    2510  *                              If NULL, an own (local) ATS server will be created.
    2511  */
    2512 static int audioTestDoSelftestAts(PCPDMDRVREG pDrvReg, const char *pszAdr)
    2513 {
    2514     AUDIOTESTENV TstEnv;
    2515     int rc = audioTestDriverStackInit(&TstEnv.DrvStack, pDrvReg, true /* fWithDrvAudio */);
     2657 * @param   pCtx                Self test context to use.
     2658 */
     2659static int audioTestDoSelftest(PSELFTESTCTX pCtx)
     2660{
     2661    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,  "Running self test ...\n");
     2662
     2663    /*
     2664     * The self-test does the following:
     2665     * - 1. Creates an ATS instance to emulate the guest mode ("--mode guest")
     2666     *      at port 6042 (ATS_ALT_PORT).
     2667     * - 2. Uses the Validation Kit audio backend, which in turn creates an ATS instance
     2668     *      at port 6052 (ATS_DEFAULT_PORT).
     2669     * - 3. Executes a complete test run locally (e.g. without any guest (VM) involved).
     2670     */
     2671
     2672    AUDIOTESTPARMS TstCust;
     2673    audioTestParmsInit(&TstCust);
     2674
     2675    /* Generate a common tag for guest and host side. */
     2676    int rc = AudioTestGenTag(pCtx->szTag, sizeof(pCtx->szTag));
     2677    AssertRCReturn(rc, rc);
     2678
     2679    PAUDIOTESTENV pTstEnv = &pCtx->Host.TstEnv;
     2680
     2681    /* Flag the environment for self test mode. */
     2682    pTstEnv->fSelftest = true;
     2683
     2684    /* Generate tag for host side. */
     2685    rc = RTStrCopy(pTstEnv->szTag, sizeof(pTstEnv->szTag), pCtx->szTag);
     2686    AssertRCReturn(rc, rc);
     2687
     2688    rc = AudioTestPathCreateTemp(pTstEnv->szPathTemp, sizeof(pTstEnv->szPathTemp), "selftest-host");
     2689    AssertRCReturn(rc, rc);
     2690
     2691    rc = AudioTestPathCreateTemp(pTstEnv->szPathOut, sizeof(pTstEnv->szPathOut), "selftest-out");
     2692    AssertRCReturn(rc, rc);
     2693
     2694    /*
     2695     * Step 1.
     2696     * Creates a separate thread for the guest ATS.
     2697     */
     2698    RTTHREAD hThreadGstAts;
     2699    rc = RTThreadCreate(&hThreadGstAts, audioTestSelftestGuestAtsThread, pCtx, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE,
     2700                        "VKATGstAts");
    25162701    if (RT_SUCCESS(rc))
    25172702    {
    2518         /** @todo Make stream parameters configurable. */
    2519         PDMAUDIOPCMPROPS  Props;
    2520         PDMAudioPropsInit(&Props, 16 /* bit */ / 8, true /* fSigned */, 2 /* Channels */, 44100 /* Hz */);
    2521 
    2522         PDMAUDIOSTREAMCFG CfgAcq;
    2523         PPDMAUDIOSTREAM   pStream = NULL;
    2524         rc = audioTestDriverStackStreamCreateOutput(&TstEnv.DrvStack, &Props,
    2525                                                     UINT32_MAX /* cMsBufferSize */,
    2526                                                     UINT32_MAX /* cMsPreBuffer */,
    2527                                                     UINT32_MAX /* cMsSchedulingHint */, &pStream, &CfgAcq);
     2703        rc = RTThreadUserWait(hThreadGstAts, RT_MS_30SEC);
    25282704        if (RT_SUCCESS(rc))
    25292705        {
    2530             rc = audioTestDriverStackStreamEnable(&TstEnv.DrvStack, pStream);
     2706            /*
     2707             * Steps 2 + 3.
     2708             */
     2709            pTstEnv->enmMode = AUDIOTESTMODE_HOST;
     2710
     2711            if (!pCtx->Host.uGuestAtsPort)
     2712                pCtx->Host.uGuestAtsPort = ATS_TCP_ALT_PORT;
     2713
     2714            rc = audioTestEnvInit(pTstEnv, &g_DrvHostValidationKitAudio, true /* fWithDrvAudio */,
     2715                                  pCtx->Host.szGuestAtsAddr, pCtx->Host.uGuestAtsPort);
    25312716            if (RT_SUCCESS(rc))
    25322717            {
    2533                 ATSCALLBACKCTX Ctx;
    2534                 Ctx.pTstEnv = &TstEnv;
    2535 
    2536                 ATSCALLBACKS Callbacks;
    2537                 Callbacks.pfnTonePlay = audioTestSvcTonePlayCallback;
    2538                 Callbacks.pvUser      = &Ctx;
    2539 
    2540                 /* Start an own ATS instance if no address to connect was specified. */
    2541                 ATSSERVER Srv;
    2542                 if (pszAdr == NULL)
    2543                 {
    2544                     RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Starting ATS ...\n");
    2545 
    2546                     rc = AudioTestSvcInit(&Srv, &Callbacks);
    2547                     if (RT_SUCCESS(rc))
    2548                         rc = AudioTestSvcStart(&Srv);
    2549                 }
    2550                 else
    2551                     RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connecting to ATS at '%s' ...\n", pszAdr);
    2552 
    2553                 if (RT_SUCCESS(rc))
    2554                 {
    2555                     ATSCLIENT Conn;
    2556                     rc = AudioTestSvcClientConnect(&Conn, NULL, 0);
    2557                     if (RT_SUCCESS(rc))
    2558                     {
    2559                         RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connected to ATS, testing ...\n");
    2560 
    2561                         /* Do the bare minimum here to get a test tone out. */
    2562                         AUDIOTESTTONEPARMS ToneParms;
    2563                         RT_ZERO(ToneParms);
    2564                         ToneParms.msDuration = RTRandU32Ex(250, 1000 * 5);
    2565                         memcpy(&ToneParms.Props, &CfgAcq.Props, sizeof(PDMAUDIOPCMPROPS));
    2566 
    2567                         rc = AudioTestSvcClientTonePlay(&Conn, &ToneParms);
    2568 
    2569                         int rc2 = AudioTestSvcClientClose(&Conn);
    2570                         if (RT_SUCCESS(rc))
    2571                             rc = rc2;
    2572                     }
    2573                     else
    2574                         RTTestFailed(g_hTest, "Connecting to ATS failed, rc=%Rrc\n", rc);
    2575 
    2576                     int rc2 = AudioTestSvcShutdown(&Srv);
    2577                     if (RT_SUCCESS(rc))
    2578                         rc = rc2;
    2579                 }
    2580 
    2581                 if (pszAdr == NULL)
    2582                 {
    2583                     RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Shutting down ATS ...\n");
    2584 
    2585                     int rc2 = AudioTestSvcDestroy(&Srv);
    2586                         if (RT_SUCCESS(rc))
    2587                             rc = rc2;
    2588                 }
     2718                audioTestWorker(pTstEnv, &TstCust);
     2719                audioTestEnvDestroy(pTstEnv);
    25892720            }
    25902721        }
    25912722    }
    25922723
     2724    audioTestParmsDestroy(&TstCust);
     2725
     2726    /*
     2727     * Shutting down.
     2728     */
     2729    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,  "Shutting down self test\n");
     2730
     2731    ASMAtomicWriteBool(&g_fTerminate, true);
     2732
     2733    int rcThread;
     2734    int rc2 = RTThreadWait(hThreadGstAts, RT_MS_30SEC, &rcThread);
     2735    if (RT_SUCCESS(rc2))
     2736        rc2 = rcThread;
     2737    if (RT_FAILURE(rc2))
     2738        RTTestFailed(g_hTest, "Shutting down self test failed with %Rrc\n", rc2);
     2739
     2740    if (RT_SUCCESS(rc))
     2741        rc = rc2;
     2742
    25932743    if (RT_FAILURE(rc))
    2594         RTTestFailed(g_hTest, "Testing ATS failed with %Rrc\n", rc);
    2595 
    2596     return rc;
    2597 }
    2598 
    2599 /**
    2600  * Main function for performing the self-tests.
    2601  *
    2602  * @returns VBox status code.
    2603  * @param   pDrvReg             Backend driver to use.
    2604  * @param   pszAtsAdr           Address of ATS server to connect to.
    2605  *                              If NULL, an own (local) ATS server will be created.
    2606  */
    2607 static int audioTestDoSelftest(PCPDMDRVREG pDrvReg, const char *pszAtsAdr)
    2608 {
    2609     int rc = audioTestDoSelftestAts(pDrvReg, pszAtsAdr);
    2610     if (RT_FAILURE(rc))
    2611         RTTestFailed(g_hTest, "Self-test failed with: %Rrc", rc);
     2744        RTTestFailed(g_hTest, "Self test failed with %Rrc\n", rc);
    26122745
    26132746    return rc;
    … …  
    26222755static DECLCALLBACK(RTEXITCODE) audioTestCmdSelftestHandler(PRTGETOPTSTATE pGetState)
    26232756{
    2624     /* Option values: */
    2625     PCPDMDRVREG pDrvReg           = g_aBackends[0].pDrvReg;
    2626     bool        fWithDrvAudio     = false;
    2627     const char *pszAtsAddr        = NULL;
     2757    SELFTESTCTX Ctx;
     2758    RT_ZERO(Ctx);
     2759
     2760    /* Go with the platform's default bakcend if nothing else is specified. */
     2761    Ctx.Guest.pDrvReg = g_aBackends[0].pDrvReg;
    26282762
    26292763    /* Argument processing loop: */
    … …  
    26342768        switch (rc)
    26352769        {
    2636             case VKAT_SELFTEST_OPT_ATS_HOST:
    2637                 pszAtsAddr = ValueUnion.psz;
     2770            case VKAT_SELFTEST_OPT_ATS_GUEST_ADDR:
     2771                rc = RTStrCopy(Ctx.Host.szGuestAtsAddr, sizeof(Ctx.Host.szGuestAtsAddr), ValueUnion.psz);
     2772                break;
     2773
     2774            case VKAT_SELFTEST_OPT_ATS_GUEST_PORT:
     2775                Ctx.Host.uGuestAtsPort = ValueUnion.u32;
     2776                break;
     2777
     2778            case VKAT_SELFTEST_OPT_ATS_VALKIT_ADDR:
     2779                rc = RTStrCopy(Ctx.Host.szValKitAtsAddr, sizeof(Ctx.Host.szValKitAtsAddr), ValueUnion.psz);
     2780                break;
     2781
     2782            case VKAT_SELFTEST_OPT_ATS_VALKIT_PORT:
     2783                Ctx.Host.uValKitAtsPort = ValueUnion.u32;
     2784                break;
     2785
     2786            case 'a':
     2787                for (unsigned i = 0; i < RT_ELEMENTS(g_aTests); i++)
     2788                    g_aTests[i].fExcluded = true;
    26382789                break;
    26392790
    26402791            case 'b':
    2641                 pDrvReg = audioTestFindBackendOpt(ValueUnion.psz);
    2642                 if (pDrvReg == NULL)
     2792            {
     2793                Ctx.Guest.pDrvReg = audioTestFindBackendOpt(ValueUnion.psz);
     2794                if (Ctx.Guest.pDrvReg == NULL)
    26432795                    return RTEXITCODE_SYNTAX;
    26442796                break;
     2797            }
    26452798
    26462799            case 'd':
    2647                 fWithDrvAudio = true;
     2800                Ctx.fWithDrvAudio = true;
     2801                break;
     2802
     2803            case 'e':
     2804                if (ValueUnion.u32 >= RT_ELEMENTS(g_aTests))
     2805                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid test number %u passed to --exclude", ValueUnion.u32);
     2806                g_aTests[ValueUnion.u32].fExcluded = true;
     2807                break;
     2808
     2809            case 'i':
     2810                if (ValueUnion.u32 >= RT_ELEMENTS(g_aTests))
     2811                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid test number %u passed to --include", ValueUnion.u32);
     2812                g_aTests[ValueUnion.u32].fExcluded = false;
    26482813                break;
    26492814
    … …  
    26552820    }
    26562821
    2657     audioTestDoSelftest(pDrvReg, pszAtsAddr);
     2822    /*
     2823     * Start testing.
     2824     */
     2825    RTTestBanner(g_hTest);
     2826
     2827    int rc2 = audioTestDoSelftest(&Ctx);
     2828    if (RT_FAILURE(rc2))
     2829        RTTestFailed(g_hTest, "Self test failed with rc=%Rrc", rc2);
    26582830
    26592831    /*
Note: See TracChangeset for help on using the changeset viewer.

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