VirtualBox

Ignore:
Timestamp:
Aug 2, 2016 10:34:23 PM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
109488
Message:

tstUsbMouse: Fixed.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Input/testcase/tstUsbMouse.cpp

    r62513 r62888  
    4646    /** Is multi-touch mode currently supported? */
    4747    bool                        fMT;
    48 } DRVTSTMOUSE, *PDRVTSTMOUSE;
    49 
    50 
     48} DRVTSTMOUSE;
     49typedef DRVTSTMOUSE *PDRVTSTMOUSE;
     50
     51
     52/*********************************************************************************************************************************
     53*   Global Variables                                                                                                             *
     54*********************************************************************************************************************************/
     55static PDMUSBHLP   g_tstUsbHlp;
    5156/** Global mouse driver variable.
    5257 * @todo To be improved some time. */
    53 static DRVTSTMOUSE s_drvTstMouse;
     58static DRVTSTMOUSE g_drvTstMouse;
    5459
    5560
    … …  
    6873/** @todo We currently just take the driver interface from the global
    6974 * variable.  This is sufficient for a unit test but still a bit sad. */
    70 static DECLCALLBACK(int) tstDriverAttach(PPDMUSBINS pUsbIns, RTUINT iLun,
    71                                          PPDMIBASE pBaseInterface,
    72                                          PPDMIBASE *ppBaseInterface,
    73                                          const char *pszDesc)
    74 {
    75     NOREF(iLun);
    76     NOREF(pszDesc);
    77     s_drvTstMouse.pDrvBase = pBaseInterface;
    78     s_drvTstMouse.pDrv = PDMIBASE_QUERY_INTERFACE(pBaseInterface,
    79                                                   PDMIMOUSEPORT);
    80     *ppBaseInterface = &s_drvTstMouse.IBase;
     75static DECLCALLBACK(int) tstDriverAttach(PPDMUSBINS pUsbIns, RTUINT iLun, PPDMIBASE pBaseInterface,
     76                                         PPDMIBASE *ppBaseInterface, const char *pszDesc)
     77{
     78    RT_NOREF3(pUsbIns, iLun, pszDesc);
     79    g_drvTstMouse.pDrvBase = pBaseInterface;
     80    g_drvTstMouse.pDrv = PDMIBASE_QUERY_INTERFACE(pBaseInterface, PDMIMOUSEPORT);
     81    *ppBaseInterface = &g_drvTstMouse.IBase;
    8182    return VINF_SUCCESS;
    8283}
    83 
    84 
    85 static PDMUSBHLP s_tstUsbHlp;
    8684
    8785
    … …  
    9290                                                   const char *pszIID)
    9391{
    94     PDRVTSTMOUSE pThis = RT_FROM_MEMBER(pInterface, DRVTSTMOUSE, IBase);
    95     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
    96     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSECONNECTOR, &pThis->IConnector);
     92    PDRVTSTMOUSE pUsbIns = RT_FROM_MEMBER(pInterface, DRVTSTMOUSE, IBase);
     93    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pUsbIns->IBase);
     94    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSECONNECTOR, &pUsbIns->IConnector);
    9795    return NULL;
    9896}
    … …  
    113111
    114112static int tstMouseConstruct(int iInstance, const char *pcszMode,
    115                              uint8_t u8CoordShift, PPDMUSBINS *ppThis)
     113                             uint8_t u8CoordShift, PPDMUSBINS *ppThis,
     114                             uint32_t uInstanceVersion = PDM_USBINS_VERSION)
    116115{
    117116    int rc = VERR_NO_MEMORY;
    118     PPDMUSBINS pThis = (PPDMUSBINS)RTMemAllocZ(  sizeof(*pThis)
     117    PPDMUSBINS pUsbIns = (PPDMUSBINS)RTMemAllocZ(  sizeof(*pUsbIns)
    119118                                               + g_UsbHidMou.cbInstance);
    120119    PCFGMNODE pCfg = NULL;
    121     if (pThis)
     120    if (pUsbIns)
    122121    pCfg = CFGMR3CreateTree(NULL);
    123122    if (pCfg)
    … …  
    127126    if (RT_SUCCESS(rc))
    128127    {
    129         s_drvTstMouse.pDrv = NULL;
    130         s_drvTstMouse.pDrvBase = NULL;
    131         pThis->iInstance = iInstance;
    132         pThis->pHlpR3 = &s_tstUsbHlp;
    133         rc = g_UsbHidMou.pfnConstruct(pThis, iInstance, pCfg, NULL);
     128        g_drvTstMouse.pDrv     = NULL;
     129        g_drvTstMouse.pDrvBase = NULL;
     130        pUsbIns->u32Version = uInstanceVersion;
     131        pUsbIns->iInstance  = iInstance;
     132        pUsbIns->pHlpR3     = &g_tstUsbHlp;
     133        rc = g_UsbHidMou.pfnConstruct(pUsbIns, iInstance, pCfg, NULL);
    134134        if (RT_SUCCESS(rc))
    135135        {
    136            *ppThis = pThis;
     136           *ppThis = pUsbIns;
    137137           return rc;
    138138        }
    … …  
    141141    if (pCfg)
    142142        CFGMR3DestroyTree(pCfg);
    143     if (pThis)
    144         RTMemFree(pThis);
     143    if (pUsbIns)
     144        RTMemFree(pUsbIns);
    145145    return rc;
    146146}
    … …  
    149149static void testConstructAndDestruct(RTTEST hTest)
    150150{
    151     PPDMUSBINS pThis;
    152151    RTTestSub(hTest, "simple construction and destruction");
    153     int rc = tstMouseConstruct(0, "relative", 1, &pThis);
    154     RTTEST_CHECK_RC_OK(hTest, rc);
    155     if (pThis)
    156         g_UsbHidMou.pfnDestruct(pThis);
     152
     153    /*
     154     * Normal check first.
     155     */
     156    PPDMUSBINS pUsbIns = NULL;
     157    RTTEST_CHECK_RC(hTest, tstMouseConstruct(0, "relative", 1, &pUsbIns), VINF_SUCCESS);
     158    if (pUsbIns)
     159        g_UsbHidMou.pfnDestruct(pUsbIns);
     160
     161    /*
     162     * Modify the dev hlp version.
     163     */
     164    static struct
     165    {
     166        int         rc;
     167        uint32_t    uInsVersion;
     168        uint32_t    uHlpVersion;
     169    } const s_aVersionTests[] =
     170    {
     171        {  VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, 0 },
     172        {  VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION - PDM_VERSION_MAKE(0, 1, 0) },
     173        {  VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION + PDM_VERSION_MAKE(0, 1, 0) },
     174        {  VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION + PDM_VERSION_MAKE(0, 1, 1) },
     175        {  VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION + PDM_VERSION_MAKE(1, 0, 0) },
     176        {  VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION - PDM_VERSION_MAKE(1, 0, 0) },
     177        {  VINF_SUCCESS,                       PDM_USBINS_VERSION, PDM_USBHLP_VERSION + PDM_VERSION_MAKE(0, 0, 1) },
     178        {  VERR_PDM_USBINS_VERSION_MISMATCH,   PDM_USBINS_VERSION - PDM_VERSION_MAKE(0, 1, 0), PDM_USBHLP_VERSION },
     179        {  VERR_PDM_USBINS_VERSION_MISMATCH,   PDM_USBINS_VERSION + PDM_VERSION_MAKE(0, 1, 0), PDM_USBHLP_VERSION },
     180        {  VERR_PDM_USBINS_VERSION_MISMATCH,   PDM_USBINS_VERSION + PDM_VERSION_MAKE(0, 1, 1), PDM_USBHLP_VERSION },
     181        {  VERR_PDM_USBINS_VERSION_MISMATCH,   PDM_USBINS_VERSION + PDM_VERSION_MAKE(1, 0, 0), PDM_USBHLP_VERSION },
     182        {  VERR_PDM_USBINS_VERSION_MISMATCH,   PDM_USBINS_VERSION - PDM_VERSION_MAKE(1, 0, 0), PDM_USBHLP_VERSION },
     183        {  VINF_SUCCESS,                       PDM_USBINS_VERSION + PDM_VERSION_MAKE(0, 0, 1), PDM_USBHLP_VERSION },
     184        {  VINF_SUCCESS,
     185           PDM_USBINS_VERSION + PDM_VERSION_MAKE(0, 0, 1),         PDM_USBHLP_VERSION + PDM_VERSION_MAKE(0, 0, 1) },
     186    };
     187    bool const fSavedMayPanic = RTAssertSetMayPanic(false);
     188    bool const fSavedQuiet    = RTAssertSetQuiet(true);
     189    for (unsigned i = 0; i < RT_ELEMENTS(s_aVersionTests); i++)
     190    {
     191        g_tstUsbHlp.u32Version = g_tstUsbHlp.u32TheEnd = s_aVersionTests[i].uHlpVersion;
     192        pUsbIns = NULL;
     193        RTTEST_CHECK_RC(hTest, tstMouseConstruct(0, "relative", 1, &pUsbIns, s_aVersionTests[i].uInsVersion),
     194                        s_aVersionTests[i].rc);
     195    }
     196    RTAssertSetMayPanic(fSavedMayPanic);
     197    RTAssertSetQuiet(fSavedQuiet);
     198
     199    g_tstUsbHlp.u32Version = g_tstUsbHlp.u32TheEnd = PDM_USBHLP_VERSION;
    157200}
    158201
    … …  
    160203static void testSendPositionRel(RTTEST hTest)
    161204{
    162     PPDMUSBINS pThis = NULL;
     205    PPDMUSBINS pUsbIns = NULL;
    163206    VUSBURB Urb;
    164207    RTTestSub(hTest, "sending a relative position event");
    165     int rc = tstMouseConstruct(0, "relative", 1, &pThis);
     208    int rc = tstMouseConstruct(0, "relative", 1, &pUsbIns);
    166209    RT_ZERO(Urb);
    167210    if (RT_SUCCESS(rc))
    168         rc = g_UsbHidMou.pfnUsbReset(pThis, false);
    169     if (RT_SUCCESS(rc) && !s_drvTstMouse.pDrv)
     211        rc = g_UsbHidMou.pfnUsbReset(pUsbIns, false);
     212    if (RT_SUCCESS(rc) && !g_drvTstMouse.pDrv)
    170213        rc = VERR_PDM_MISSING_INTERFACE;
    171214    RTTEST_CHECK_RC_OK(hTest, rc);
    172215    if (RT_SUCCESS(rc))
    173216    {
    174         s_drvTstMouse.pDrv->pfnPutEvent(s_drvTstMouse.pDrv, 123, -16, 1, -1, 3);
     217        g_drvTstMouse.pDrv->pfnPutEvent(g_drvTstMouse.pDrv, 123, -16, 1, -1, 3);
    175218        Urb.EndPt = 0x01;
    176         rc = g_UsbHidMou.pfnUrbQueue(pThis, &Urb);
    177     }
    178     if (RT_SUCCESS(rc))
    179     {
    180         PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pThis, 0);
     219        rc = g_UsbHidMou.pfnUrbQueue(pUsbIns, &Urb);
     220    }
     221    if (RT_SUCCESS(rc))
     222    {
     223        PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pUsbIns, 0);
    181224        if (pUrb)
    182225        {
    … …  
    196239    }
    197240    RTTEST_CHECK_RC_OK(hTest, rc);
    198     if (pThis)
    199         g_UsbHidMou.pfnDestruct(pThis);
     241    if (pUsbIns)
     242        g_UsbHidMou.pfnDestruct(pUsbIns);
    200243}
    201244
    … …  
    203246static void testSendPositionAbs(RTTEST hTest)
    204247{
    205     PPDMUSBINS pThis = NULL;
     248    PPDMUSBINS pUsbIns = NULL;
    206249    VUSBURB Urb;
    207250    RTTestSub(hTest, "sending an absolute position event");
    208     int rc = tstMouseConstruct(0, "absolute", 1, &pThis);
     251    int rc = tstMouseConstruct(0, "absolute", 1, &pUsbIns);
    209252    RT_ZERO(Urb);
    210253    if (RT_SUCCESS(rc))
    211254    {
    212         rc = g_UsbHidMou.pfnUsbReset(pThis, false);
    213     }
    214     if (RT_SUCCESS(rc))
    215     {
    216         if (s_drvTstMouse.pDrv)
    217             s_drvTstMouse.pDrv->pfnPutEventAbs(s_drvTstMouse.pDrv, 300, 200, 1,
     255        rc = g_UsbHidMou.pfnUsbReset(pUsbIns, false);
     256    }
     257    if (RT_SUCCESS(rc))
     258    {
     259        if (g_drvTstMouse.pDrv)
     260            g_drvTstMouse.pDrv->pfnPutEventAbs(g_drvTstMouse.pDrv, 300, 200, 1,
    218261                                               3, 3);
    219262        else
    … …  
    223266    {
    224267        Urb.EndPt = 0x01;
    225         rc = g_UsbHidMou.pfnUrbQueue(pThis, &Urb);
    226     }
    227     if (RT_SUCCESS(rc))
    228     {
    229         PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pThis, 0);
     268        rc = g_UsbHidMou.pfnUrbQueue(pUsbIns, &Urb);
     269    }
     270    if (RT_SUCCESS(rc))
     271    {
     272        PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pUsbIns, 0);
    230273        if (pUrb)
    231274        {
    … …  
    246289    }
    247290    RTTEST_CHECK_RC_OK(hTest, rc);
    248     if (pThis)
    249         g_UsbHidMou.pfnDestruct(pThis);
     291    if (pUsbIns)
     292        g_UsbHidMou.pfnDestruct(pUsbIns);
    250293}
    251294
    … …  
    254297static void testSendPositionMT(RTTEST hTest)
    255298{
    256     PPDMUSBINS pThis = NULL;
     299    PPDMUSBINS pUsbIns = NULL;
    257300    VUSBURB Urb;
    258301    RTTestSub(hTest, "sending a multi-touch position event");
    259     int rc = tstMouseConstruct(0, "multitouch", 1, &pThis);
     302    int rc = tstMouseConstruct(0, "multitouch", 1, &pUsbIns);
    260303    RT_ZERO(Urb);
    261304    if (RT_SUCCESS(rc))
    262305    {
    263         rc = g_UsbHidMou.pfnUsbReset(pThis, false);
    264     }
    265     if (RT_SUCCESS(rc))
    266     {
    267         if (s_drvTstMouse.pDrv)
    268             s_drvTstMouse.pDrv->pfnPutEventMT(s_drvTstMouse.pDrv, 300, 200, 2,
     306        rc = g_UsbHidMou.pfnUsbReset(pUsbIns, false);
     307    }
     308    if (RT_SUCCESS(rc))
     309    {
     310        if (g_drvTstMouse.pDrv)
     311            g_drvTstMouse.pDrv->pfnPutEventMT(g_drvTstMouse.pDrv, 300, 200, 2,
    269312                                              3);
    270313        else
    … …  
    274317    {
    275318        Urb.EndPt = 0x01;
    276         rc = g_UsbHidMou.pfnUrbQueue(pThis, &Urb);
    277     }
    278     if (RT_SUCCESS(rc))
    279     {
    280         PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pThis, 0);
     319        rc = g_UsbHidMou.pfnUrbQueue(pUsbIns, &Urb);
     320    }
     321    if (RT_SUCCESS(rc))
     322    {
     323        PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pUsbIns, 0);
    281324        if (pUrb)
    282325        {
    … …  
    297340    }
    298341    RTTEST_CHECK_RC_OK(hTest, rc);
    299     if (pThis)
    300         g_UsbHidMou.pfnDestruct(pThis);
     342    if (pUsbIns)
     343        g_UsbHidMou.pfnDestruct(pUsbIns);
    301344}
    302345#endif
    … …  
    313356    RTTestBanner(hTest);
    314357    /* Set up our faked PDMUSBHLP interface. */
    315     s_tstUsbHlp.pfnVMSetErrorV  = tstVMSetErrorV;
    316     s_tstUsbHlp.pfnDriverAttach = tstDriverAttach;
     358    g_tstUsbHlp.u32Version      = PDM_USBHLP_VERSION;
     359    g_tstUsbHlp.pfnVMSetErrorV  = tstVMSetErrorV;
     360    g_tstUsbHlp.pfnDriverAttach = tstDriverAttach;
     361    g_tstUsbHlp.u32TheEnd       = PDM_USBHLP_VERSION;
    317362    /* Set up our global mouse driver */
    318     s_drvTstMouse.IBase.pfnQueryInterface = tstMouseQueryInterface;
    319     s_drvTstMouse.IConnector.pfnReportModes = tstMouseReportModes;
     363    g_drvTstMouse.IBase.pfnQueryInterface = tstMouseQueryInterface;
     364    g_drvTstMouse.IConnector.pfnReportModes = tstMouseReportModes;
    320365
    321366    /*
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