tstUsbMouse.cpp@ 82463

Last change on this file since 82463 was 81067, checked in by vboxsync, 5 years ago
tstUsbMouse: Must initialize pvInstanceDataR3 or PDMINS_2_DATA will return NULL. The macro changed when PDMDEVINS made it return pointer to the shared data rather than the new private data now residing at achInstanceData. bugref:9218
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 14.3 KB

Line
1	/* $Id: tstUsbMouse.cpp 81067 2019-09-28 00:52:26Z vboxsync $ */
2	/** @file
3	* tstUsbMouse.cpp - testcase USB mouse and tablet devices.
4	*/
5
6	/*
7	* Copyright (C) 2013-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include "VBoxDD.h"
23	#include <VBox/vmm/pdmdrv.h>
24	#include <iprt/mem.h>
25	#include <iprt/rand.h>
26	#include <iprt/stream.h>
27	#include <iprt/test.h>
28	#include <iprt/uuid.h>
29
30
31	/*********************************************************************************************************************************
32	* Structures and Typedefs *
33	*********************************************************************************************************************************/
34	/** Test mouse driver structure. */
35	typedef struct DRVTSTMOUSE
36	{
37	/** The USBHID structure. */
38	struct USBHID *pUsbHid;
39	/** The base interface for the mouse driver. */
40	PDMIBASE IBase;
41	/** Our mouse connector interface. */
42	PDMIMOUSECONNECTOR IConnector;
43	/** The base interface of the attached mouse port. */
44	PPDMIBASE pDrvBase;
45	/** The mouse port interface of the attached mouse port. */
46	PPDMIMOUSEPORT pDrv;
47	/** Is relative mode currently supported? */
48	bool fRel;
49	/** Is absolute mode currently supported? */
50	bool fAbs;
51	/** Is multi-touch mode currently supported? */
52	bool fMT;
53	} DRVTSTMOUSE;
54	typedef DRVTSTMOUSE *PDRVTSTMOUSE;
55
56
57	/*********************************************************************************************************************************
58	* Global Variables *
59	*********************************************************************************************************************************/
60	static PDMUSBHLP g_tstUsbHlp;
61	/** Global mouse driver variable.
62	* @todo To be improved some time. */
63	static DRVTSTMOUSE g_drvTstMouse;
64
65
66	/** @interface_method_impl{PDMUSBHLPR3,pfnVMSetErrorV} */
67	static DECLCALLBACK(int) tstVMSetErrorV(PPDMUSBINS pUsbIns, int rc,
68	RT_SRC_POS_DECL, const char *pszFormat,
69	va_list va)
70	{
71	RT_NOREF(pUsbIns);
72	RTPrintf("Error: %s:%u:%s:", RT_SRC_POS_ARGS);
73	RTPrintfV(pszFormat, va);
74	return rc;
75	}
76
77	/** @interface_method_impl{PDMUSBHLPR3,pfnDriverAttach} */
78	/** @todo We currently just take the driver interface from the global
79	* variable. This is sufficient for a unit test but still a bit sad. */
80	static DECLCALLBACK(int) tstDriverAttach(PPDMUSBINS pUsbIns, RTUINT iLun, PPDMIBASE pBaseInterface,
81	PPDMIBASE ppBaseInterface, const char pszDesc)
82	{
83	RT_NOREF3(pUsbIns, iLun, pszDesc);
84	g_drvTstMouse.pDrvBase = pBaseInterface;
85	g_drvTstMouse.pDrv = PDMIBASE_QUERY_INTERFACE(pBaseInterface, PDMIMOUSEPORT);
86	*ppBaseInterface = &g_drvTstMouse.IBase;
87	return VINF_SUCCESS;
88	}
89
90
91	/**
92	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
93	*/
94	static DECLCALLBACK(void *) tstMouseQueryInterface(PPDMIBASE pInterface,
95	const char *pszIID)
96	{
97	PDRVTSTMOUSE pUsbIns = RT_FROM_MEMBER(pInterface, DRVTSTMOUSE, IBase);
98	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pUsbIns->IBase);
99	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSECONNECTOR, &pUsbIns->IConnector);
100	return NULL;
101	}
102
103
104	/**
105	* @interface_method_impl{PDMIMOUSECONNECTOR,pfnReportModes}
106	*/
107	static DECLCALLBACK(void) tstMouseReportModes(PPDMIMOUSECONNECTOR pInterface,
108	bool fRel, bool fAbs, bool fMT)
109	{
110	PDRVTSTMOUSE pDrv = RT_FROM_MEMBER(pInterface, DRVTSTMOUSE, IConnector);
111	pDrv->fRel = fRel;
112	pDrv->fAbs = fAbs;
113	pDrv->fMT = fMT;
114	}
115
116
117	static int tstMouseConstruct(RTTEST hTest, int iInstance, const char *pcszMode,
118	uint8_t u8CoordShift, PPDMUSBINS *ppThis,
119	uint32_t uInstanceVersion = PDM_USBINS_VERSION)
120	{
121	size_t cbUsbIns = RT_UOFFSETOF(PDMUSBINS, achInstanceData) + g_UsbHidMou.cbInstance;
122	PPDMUSBINS pUsbIns;
123	int rc = RTTestGuardedAlloc(hTest, cbUsbIns, 1, RTRandU32Ex(0, 1) != 0 /fHead/, (void **)&pUsbIns);
124	if (RT_SUCCESS(rc))
125	{
126	RT_BZERO(pUsbIns, cbUsbIns);
127
128	PCFGMNODE pCfg = CFGMR3CreateTree(NULL);
129	if (pCfg)
130	{
131	rc = CFGMR3InsertString(pCfg, "Mode", pcszMode);
132	if (RT_SUCCESS(rc))
133	rc = CFGMR3InsertInteger(pCfg, "CoordShift", u8CoordShift);
134	if (RT_SUCCESS(rc))
135	{
136	g_drvTstMouse.pDrv = NULL;
137	g_drvTstMouse.pDrvBase = NULL;
138	pUsbIns->u32Version = uInstanceVersion;
139	pUsbIns->iInstance = iInstance;
140	pUsbIns->pHlpR3 = &g_tstUsbHlp;
141	pUsbIns->pvInstanceDataR3 = pUsbIns->achInstanceData;
142	rc = g_UsbHidMou.pfnConstruct(pUsbIns, iInstance, pCfg, NULL);
143	if (RT_SUCCESS(rc))
144	{
145	*ppThis = pUsbIns;
146	return rc;
147	}
148	}
149	/* Failure */
150	CFGMR3DestroyTree(pCfg);
151	}
152	}
153	RTTestGuardedFree(hTest, pUsbIns);
154	return rc;
155	}
156
157
158	static void testConstructAndDestruct(RTTEST hTest)
159	{
160	RTTestSub(hTest, "simple construction and destruction");
161
162	/*
163	* Normal check first.
164	*/
165	PPDMUSBINS pUsbIns = NULL;
166	RTTEST_CHECK_RC(hTest, tstMouseConstruct(hTest, 0, "relative", 1, &pUsbIns), VINF_SUCCESS);
167	if (pUsbIns)
168	{
169	g_UsbHidMou.pfnDestruct(pUsbIns);
170	RTTestGuardedFree(hTest, pUsbIns);
171	}
172
173	/*
174	* Modify the dev hlp version.
175	*/
176	static struct
177	{
178	int rc;
179	uint32_t uInsVersion;
180	uint32_t uHlpVersion;
181	} const s_aVersionTests[] =
182	{
183	{ VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, 0 },
184	{ VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION - PDM_VERSION_MAKE(0, 1, 0) },
185	{ VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION + PDM_VERSION_MAKE(0, 1, 0) },
186	{ VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION + PDM_VERSION_MAKE(0, 1, 1) },
187	{ VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION + PDM_VERSION_MAKE(1, 0, 0) },
188	{ VERR_PDM_USBHLPR3_VERSION_MISMATCH, PDM_USBINS_VERSION, PDM_USBHLP_VERSION - PDM_VERSION_MAKE(1, 0, 0) },
189	{ VINF_SUCCESS, PDM_USBINS_VERSION, PDM_USBHLP_VERSION + PDM_VERSION_MAKE(0, 0, 1) },
190	{ VERR_PDM_USBINS_VERSION_MISMATCH, PDM_USBINS_VERSION - PDM_VERSION_MAKE(0, 1, 0), PDM_USBHLP_VERSION },
191	{ VERR_PDM_USBINS_VERSION_MISMATCH, PDM_USBINS_VERSION + PDM_VERSION_MAKE(0, 1, 0), PDM_USBHLP_VERSION },
192	{ VERR_PDM_USBINS_VERSION_MISMATCH, PDM_USBINS_VERSION + PDM_VERSION_MAKE(0, 1, 1), PDM_USBHLP_VERSION },
193	{ VERR_PDM_USBINS_VERSION_MISMATCH, PDM_USBINS_VERSION + PDM_VERSION_MAKE(1, 0, 0), PDM_USBHLP_VERSION },
194	{ VERR_PDM_USBINS_VERSION_MISMATCH, PDM_USBINS_VERSION - PDM_VERSION_MAKE(1, 0, 0), PDM_USBHLP_VERSION },
195	{ VINF_SUCCESS, PDM_USBINS_VERSION + PDM_VERSION_MAKE(0, 0, 1), PDM_USBHLP_VERSION },
196	{ VINF_SUCCESS,
197	PDM_USBINS_VERSION + PDM_VERSION_MAKE(0, 0, 1), PDM_USBHLP_VERSION + PDM_VERSION_MAKE(0, 0, 1) },
198	};
199	bool const fSavedMayPanic = RTAssertSetMayPanic(false);
200	bool const fSavedQuiet = RTAssertSetQuiet(true);
201	for (unsigned i = 0; i < RT_ELEMENTS(s_aVersionTests); i++)
202	{
203	g_tstUsbHlp.u32Version = g_tstUsbHlp.u32TheEnd = s_aVersionTests[i].uHlpVersion;
204	pUsbIns = NULL;
205	RTTEST_CHECK_RC(hTest, tstMouseConstruct(hTest, 0, "relative", 1, &pUsbIns, s_aVersionTests[i].uInsVersion),
206	s_aVersionTests[i].rc);
207	if (pUsbIns)
208	RTTestGuardedFree(hTest, pUsbIns);
209	}
210	RTAssertSetMayPanic(fSavedMayPanic);
211	RTAssertSetQuiet(fSavedQuiet);
212
213	g_tstUsbHlp.u32Version = g_tstUsbHlp.u32TheEnd = PDM_USBHLP_VERSION;
214	}
215
216
217	static void testSendPositionRel(RTTEST hTest)
218	{
219	PPDMUSBINS pUsbIns = NULL;
220	VUSBURB Urb;
221	RTTestSub(hTest, "sending a relative position event");
222	int rc = tstMouseConstruct(hTest, 0, "relative", 1, &pUsbIns);
223	RT_ZERO(Urb);
224	if (RT_SUCCESS(rc))
225	rc = g_UsbHidMou.pfnUsbReset(pUsbIns, false);
226	if (RT_SUCCESS(rc) && !g_drvTstMouse.pDrv)
227	rc = VERR_PDM_MISSING_INTERFACE;
228	RTTEST_CHECK_RC_OK(hTest, rc);
229	if (RT_SUCCESS(rc))
230	{
231	g_drvTstMouse.pDrv->pfnPutEvent(g_drvTstMouse.pDrv, 123, -16, 1, -1, 3);
232	Urb.EndPt = 0x01;
233	rc = g_UsbHidMou.pfnUrbQueue(pUsbIns, &Urb);
234	}
235	if (RT_SUCCESS(rc))
236	{
237	PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pUsbIns, 0);
238	if (pUrb)
239	{
240	if (pUrb == &Urb)
241	{
242	if ( Urb.abData[0] != 3 /* Buttons */
243	\|\| Urb.abData[1] != 123 /* x */
244	\|\| Urb.abData[2] != 240 /* 256 - y */
245	\|\| Urb.abData[3] != 255 /* z */)
246	rc = VERR_GENERAL_FAILURE;
247	}
248	else
249	rc = VERR_GENERAL_FAILURE;
250	}
251	else
252	rc = VERR_GENERAL_FAILURE;
253	}
254	RTTEST_CHECK_RC_OK(hTest, rc);
255	if (pUsbIns)
256	{
257	g_UsbHidMou.pfnDestruct(pUsbIns);
258	RTTestGuardedFree(hTest, pUsbIns);
259	}
260	}
261
262
263	static void testSendPositionAbs(RTTEST hTest)
264	{
265	PPDMUSBINS pUsbIns = NULL;
266	VUSBURB Urb;
267	RTTestSub(hTest, "sending an absolute position event");
268	int rc = tstMouseConstruct(hTest, 0, "absolute", 1, &pUsbIns);
269	RT_ZERO(Urb);
270	if (RT_SUCCESS(rc))
271	{
272	rc = g_UsbHidMou.pfnUsbReset(pUsbIns, false);
273	}
274	if (RT_SUCCESS(rc))
275	{
276	if (g_drvTstMouse.pDrv)
277	g_drvTstMouse.pDrv->pfnPutEventAbs(g_drvTstMouse.pDrv, 300, 200, 1,
278	3, 3);
279	else
280	rc = VERR_PDM_MISSING_INTERFACE;
281	}
282	if (RT_SUCCESS(rc))
283	{
284	Urb.EndPt = 0x01;
285	rc = g_UsbHidMou.pfnUrbQueue(pUsbIns, &Urb);
286	}
287	if (RT_SUCCESS(rc))
288	{
289	PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pUsbIns, 0);
290	if (pUrb)
291	{
292	if (pUrb == &Urb)
293	{
294	if ( Urb.abData[0] != 3 /* Buttons */
295	\|\| (int8_t)Urb.abData[1] != -1 /* dz */
296	\|\| (int8_t)Urb.abData[2] != -3 /* dw */
297	\|\| (uint16_t )&Urb.abData[4] != 150 /* x >> 1 */
298	\|\| (uint16_t )&Urb.abData[6] != 100 /* y >> 1 */)
299	rc = VERR_GENERAL_FAILURE;
300	}
301	else
302	rc = VERR_GENERAL_FAILURE;
303	}
304	else
305	rc = VERR_GENERAL_FAILURE;
306	}
307	RTTEST_CHECK_RC_OK(hTest, rc);
308	if (pUsbIns)
309	{
310	g_UsbHidMou.pfnDestruct(pUsbIns);
311	RTTestGuardedFree(hTest, pUsbIns);
312	}
313	}
314
315	#if 0
316	/** @todo PDM interface was updated. This is not working anymore. */
317	static void testSendPositionMT(RTTEST hTest)
318	{
319	PPDMUSBINS pUsbIns = NULL;
320	VUSBURB Urb;
321	RTTestSub(hTest, "sending a multi-touch position event");
322	int rc = tstMouseConstruct(hTest, 0, "multitouch", 1, &pUsbIns);
323	RT_ZERO(Urb);
324	if (RT_SUCCESS(rc))
325	{
326	rc = g_UsbHidMou.pfnUsbReset(pUsbIns, false);
327	}
328	if (RT_SUCCESS(rc))
329	{
330	if (g_drvTstMouse.pDrv)
331	g_drvTstMouse.pDrv->pfnPutEventMT(g_drvTstMouse.pDrv, 300, 200, 2,
332	3);
333	else
334	rc = VERR_PDM_MISSING_INTERFACE;
335	}
336	if (RT_SUCCESS(rc))
337	{
338	Urb.EndPt = 0x01;
339	rc = g_UsbHidMou.pfnUrbQueue(pUsbIns, &Urb);
340	}
341	if (RT_SUCCESS(rc))
342	{
343	PVUSBURB pUrb = g_UsbHidMou.pfnUrbReap(pUsbIns, 0);
344	if (pUrb)
345	{
346	if (pUrb == &Urb)
347	{
348	if ( Urb.abData[0] != 1 /* Report ID */
349	\|\| Urb.abData[1] != 3 /* Contact flags */
350	\|\| (uint16_t )&Urb.abData[2] != 150 /* x >> 1 */
351	\|\| (uint16_t )&Urb.abData[4] != 100 /* y >> 1 */
352	\|\| Urb.abData[6] != 2 /* Contact number */)
353	rc = VERR_GENERAL_FAILURE;
354	}
355	else
356	rc = VERR_GENERAL_FAILURE;
357	}
358	else
359	rc = VERR_GENERAL_FAILURE;
360	}
361	RTTEST_CHECK_RC_OK(hTest, rc);
362	if (pUsbIns)
363	{
364	g_UsbHidMou.pfnDestruct(pUsbIns);
365	RTTestGuardedFree(hTest, pUsbIns);
366	}
367	}
368	#endif
369
370	int main()
371	{
372	/*
373	* Init the runtime, test and say hello.
374	*/
375	RTTEST hTest;
376	int rc = RTTestInitAndCreate("tstUsbMouse", &hTest);
377	if (rc)
378	return rc;
379	RTTestBanner(hTest);
380	/* Set up our faked PDMUSBHLP interface. */
381	g_tstUsbHlp.u32Version = PDM_USBHLP_VERSION;
382	g_tstUsbHlp.pfnVMSetErrorV = tstVMSetErrorV;
383	g_tstUsbHlp.pfnDriverAttach = tstDriverAttach;
384	g_tstUsbHlp.u32TheEnd = PDM_USBHLP_VERSION;
385	/* Set up our global mouse driver */
386	g_drvTstMouse.IBase.pfnQueryInterface = tstMouseQueryInterface;
387	g_drvTstMouse.IConnector.pfnReportModes = tstMouseReportModes;
388
389	/*
390	* Run the tests.
391	*/
392	testConstructAndDestruct(hTest);
393	testSendPositionRel(hTest);
394	testSendPositionAbs(hTest);
395	/* testSendPositionMT(hTest); */
396	return RTTestSummaryAndDestroy(hTest);
397	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Input/testcase/tstUsbMouse.cpp@ 82463

Download in other formats: