tstSharedFolderService.cpp@ 96407

Last change on this file since 96407 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 55.1 KB

Line
1	/* $Id: tstSharedFolderService.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* Testcase for the shared folder service vbsf API.
4	*
5	* Note that this is still very threadbare (there is an awful lot which should
6	* really be tested, but it already took too long to produce this much). The
7	* idea is that anyone who makes changes to the shared folders service and who
8	* cares about unit testing them should add tests to the skeleton framework to
9	* exercise the bits they change before and after changing them.
10	*/
11
12	/*
13	* Copyright (C) 2011-2022 Oracle and/or its affiliates.
14	*
15	* This file is part of VirtualBox base platform packages, as
16	* available from https://www.virtualbox.org.
17	*
18	* This program is free software; you can redistribute it and/or
19	* modify it under the terms of the GNU General Public License
20	* as published by the Free Software Foundation, in version 3 of the
21	* License.
22	*
23	* This program is distributed in the hope that it will be useful, but
24	* WITHOUT ANY WARRANTY; without even the implied warranty of
25	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26	* General Public License for more details.
27	*
28	* You should have received a copy of the GNU General Public License
29	* along with this program; if not, see <https://www.gnu.org/licenses>.
30	*
31	* SPDX-License-Identifier: GPL-3.0-only
32	*/
33
34
35	/*********************************************************************************************************************************
36	* Header Files *
37	*********************************************************************************************************************************/
38
39	#include "tstSharedFolderService.h"
40	#include "vbsf.h"
41
42	#include <iprt/fs.h>
43	#include <iprt/dir.h>
44	#include <iprt/file.h>
45	#include <iprt/path.h>
46	#include <iprt/symlink.h>
47	#include <iprt/stream.h>
48	#include <iprt/test.h>
49	#include <iprt/string.h>
50	#include <iprt/utf16.h>
51
52	#include "teststubs.h"
53
54
55	/*********************************************************************************************************************************
56	* Global Variables *
57	*********************************************************************************************************************************/
58	static RTTEST g_hTest = NIL_RTTEST;
59
60
61	/*********************************************************************************************************************************
62	* Declarations *
63	*********************************************************************************************************************************/
64	extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable);
65
66
67	/*********************************************************************************************************************************
68	* Helpers *
69	*********************************************************************************************************************************/
70
71	/** Simple call handle structure for the guest call completion callback */
72	struct VBOXHGCMCALLHANDLE_TYPEDEF
73	{
74	/** Where to store the result code */
75	int32_t rc;
76	};
77
78	/** Call completion callback for guest calls. */
79	static DECLCALLBACK(int) callComplete(VBOXHGCMCALLHANDLE callHandle, int32_t rc)
80	{
81	callHandle->rc = rc;
82	return VINF_SUCCESS;
83	}
84
85	static DECLCALLBACK(int) stamRegisterV(void pvInstance, void pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
86	STAMUNIT enmUnit, const char pszDesc, const char pszName, va_list va)
87	{
88	RT_NOREF(pvInstance, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, va);
89	return VINF_SUCCESS;
90	}
91
92	static DECLCALLBACK(int) stamDeregisterV(void pvInstance, const char pszPatFmt, va_list va)
93	{
94	RT_NOREF(pvInstance, pszPatFmt, va);
95	return VINF_SUCCESS;
96	}
97
98	static DECLCALLBACK(int) infoRegister(void pvInstance, const char pszName, const char *pszDesc,
99	PFNDBGFHANDLEREXT pfnHandler, void *pvUser)
100	{
101	RT_NOREF(pvInstance, pszName, pszDesc, pfnHandler, pvUser);
102	return VINF_SUCCESS;
103	}
104
105	static DECLCALLBACK(int) infoDeregister(void pvInstance, const char pszName)
106	{
107	RT_NOREF(pvInstance, pszName);
108	return VINF_SUCCESS;
109	}
110
111	/**
112	* Initialise the HGCM service table as much as we need to start the
113	* service
114	* @param pTable the table to initialise
115	*/
116	void initTable(VBOXHGCMSVCFNTABLE pTable, VBOXHGCMSVCHELPERS pHelpers)
117	{
118	pTable->cbSize = sizeof (VBOXHGCMSVCFNTABLE);
119	pTable->u32Version = VBOX_HGCM_SVC_VERSION;
120	pHelpers->pfnCallComplete = callComplete;
121	pHelpers->pfnStamRegisterV = stamRegisterV;
122	pHelpers->pfnStamDeregisterV = stamDeregisterV;
123	pHelpers->pfnInfoRegister = infoRegister;
124	pHelpers->pfnInfoDeregister = infoDeregister;
125	pTable->pHelpers = pHelpers;
126	}
127
128	#define LLUIFY(a) ((unsigned long long)(a))
129
130	static void bufferFromPath(char pszDst, size_t cbDst, const char pcszSrc)
131	{
132	RTStrCopy(pszDst, cbDst, pcszSrc);
133	uintptr_t const uDstEnd = (uintptr_t)&pszDst[cbDst];
134	for (char *psz = pszDst; psz && (uintptr_t)psz < uDstEnd; ++psz)
135	if (*psz == '\\')
136	*psz = '/';
137	}
138
139	#define ARRAY_FROM_PATH(a, b) \
140	do { \
141	char *p = (a); NOREF(p); \
142	Assert((a) == p); /* Constant parameter */ \
143	Assert(sizeof((a)) > 0); \
144	bufferFromPath(a, sizeof(a), b); \
145	} while (0)
146
147
148	/*********************************************************************************************************************************
149	* Stub functions and data *
150	*********************************************************************************************************************************/
151	static bool g_fFailIfNotLowercase = false;
152
153	static RTDIR g_testRTDirClose_hDir = NIL_RTDIR;
154
155	extern int testRTDirClose(RTDIR hDir)
156	{
157	/* RTPrintf("%s: hDir=%p\n", __PRETTY_FUNCTION__, hDir); */
158	g_testRTDirClose_hDir = hDir;
159	return VINF_SUCCESS;
160	}
161
162	static char g_testRTDirCreate_szPath[256];
163	//static RTFMODE testRTDirCreateMode; - unused
164
165	extern int testRTDirCreate(const char *pszPath, RTFMODE fMode, uint32_t fCreate)
166	{
167	RT_NOREF2(fMode, fCreate);
168	/* RTPrintf("%s: pszPath=%s, fMode=0x%llx\n", __PRETTY_FUNCTION__, pszPath,
169	LLUIFY(fMode)); */
170	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
171	return VERR_FILE_NOT_FOUND;
172	ARRAY_FROM_PATH(g_testRTDirCreate_szPath, pszPath);
173	return 0;
174	}
175
176	static char g_testRTDirOpen_szName[256];
177	static struct TESTDIRHANDLE
178	{
179	int iEntry;
180	int iDir;
181	} g_aTestDirHandles[4];
182	static int g_iNextDirHandle = 0;
183	static RTDIR g_testRTDirOpen_hDir;
184
185	extern int testRTDirOpen(RTDIR phDir, const char pszPath)
186	{
187	/* RTPrintf("%s: pszPath=%s\n", __PRETTY_FUNCTION__, pszPath); */
188	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
189	return VERR_FILE_NOT_FOUND;
190	ARRAY_FROM_PATH(g_testRTDirOpen_szName, pszPath);
191	*phDir = g_testRTDirOpen_hDir;
192	g_testRTDirOpen_hDir = NIL_RTDIR;
193	if (!*phDir && g_fFailIfNotLowercase)
194	*phDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
195	if (*phDir)
196	{
197	struct TESTDIRHANDLE pRealDir = (struct TESTDIRHANDLE )*phDir;
198	pRealDir->iEntry = 0;
199	pRealDir->iDir = 0;
200	const char *pszSlash = pszPath - 1;
201	while ((pszSlash = strpbrk(pszSlash + 1, "\\/")) != NULL)
202	pRealDir->iDir += 1;
203	/RTPrintf("opendir %s = %d \n", pszPath, pRealDir->iDir);/
204	}
205	return VINF_SUCCESS;
206	}
207
208	/** @todo Do something useful with the last two arguments. */
209	extern int testRTDirOpenFiltered(RTDIR phDir, const char pszPath, RTDIRFILTER, uint32_t)
210	{
211	/* RTPrintf("%s: pszPath=%s\n", __PRETTY_FUNCTION__, pszPath); */
212	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
213	return VERR_FILE_NOT_FOUND;
214	ARRAY_FROM_PATH(g_testRTDirOpen_szName, pszPath);
215	*phDir = g_testRTDirOpen_hDir;
216	g_testRTDirOpen_hDir = NIL_RTDIR;
217	if (!*phDir && g_fFailIfNotLowercase)
218	*phDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
219	if (*phDir)
220	{
221	struct TESTDIRHANDLE pRealDir = (struct TESTDIRHANDLE )*phDir;
222	pRealDir->iEntry = 0;
223	pRealDir->iDir = 0;
224	const char *pszSlash = pszPath - 1;
225	while ((pszSlash = strpbrk(pszSlash + 1, "\\/")) != NULL)
226	pRealDir->iDir += 1;
227	pRealDir->iDir -= 1;
228	/RTPrintf("openfiltered %s = %d\n", pszPath, pRealDir->iDir);/
229	}
230	return VINF_SUCCESS;
231	}
232
233	static RTDIR g_testRTDirQueryInfo_hDir;
234	static RTTIMESPEC g_testRTDirQueryInfo_ATime;
235
236	extern int testRTDirQueryInfo(RTDIR hDir, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
237	{
238	RT_NOREF1(enmAdditionalAttribs);
239	/* RTPrintf("%s: hDir=%p, enmAdditionalAttribs=0x%llx\n", __PRETTY_FUNCTION__,
240	hDir, LLUIFY(enmAdditionalAttribs)); */
241	g_testRTDirQueryInfo_hDir = hDir;
242	RT_ZERO(*pObjInfo);
243	pObjInfo->AccessTime = g_testRTDirQueryInfo_ATime;
244	RT_ZERO(g_testRTDirQueryInfo_ATime);
245	return VINF_SUCCESS;
246	}
247
248	extern int testRTDirRemove(const char *pszPath)
249	{
250	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
251	return VERR_FILE_NOT_FOUND;
252	RTPrintf("%s\n", __PRETTY_FUNCTION__);
253	return 0;
254	}
255
256	static RTDIR g_testRTDirReadEx_hDir;
257
258	extern int testRTDirReadEx(RTDIR hDir, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry,
259	RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
260	{
261	RT_NOREF4(pDirEntry, pcbDirEntry, enmAdditionalAttribs, fFlags);
262	/* RTPrintf("%s: hDir=%p, pcbDirEntry=%d, enmAdditionalAttribs=%llu, fFlags=0x%llx\n",
263	__PRETTY_FUNCTION__, hDir, pcbDirEntry ? (int) *pcbDirEntry : -1,
264	LLUIFY(enmAdditionalAttribs), LLUIFY(fFlags)); */
265	g_testRTDirReadEx_hDir = hDir;
266	if (g_fFailIfNotLowercase && hDir != NIL_RTDIR)
267	{
268	struct TESTDIRHANDLE pRealDir = (struct TESTDIRHANDLE )hDir;
269	if (pRealDir->iDir == 2) /* /test/mapping/ */
270	{
271	if (pRealDir->iEntry == 0)
272	{
273	pRealDir->iEntry++;
274	RT_ZERO(*pDirEntry);
275	pDirEntry->Info.Attr.fMode = RTFS_TYPE_DIRECTORY \| RTFS_DOS_DIRECTORY \| RTFS_UNIX_IROTH \| RTFS_UNIX_IXOTH;
276	pDirEntry->cbName = 4;
277	pDirEntry->cwcShortName = 4;
278	strcpy(pDirEntry->szName, "test");
279	RTUtf16CopyAscii(pDirEntry->wszShortName, RT_ELEMENTS(pDirEntry->wszShortName), "test");
280	/RTPrintf("readdir: 'test'\n");/
281	return VINF_SUCCESS;
282	}
283	}
284	else if (pRealDir->iDir == 3) /* /test/mapping/test/ */
285	{
286	if (pRealDir->iEntry == 0)
287	{
288	pRealDir->iEntry++;
289	RT_ZERO(*pDirEntry);
290	pDirEntry->Info.Attr.fMode = RTFS_TYPE_FILE \| RTFS_DOS_NT_NORMAL \| RTFS_UNIX_IROTH \| RTFS_UNIX_IXOTH;
291	pDirEntry->cbName = 4;
292	pDirEntry->cwcShortName = 4;
293	strcpy(pDirEntry->szName, "file");
294	RTUtf16CopyAscii(pDirEntry->wszShortName, RT_ELEMENTS(pDirEntry->wszShortName), "file");
295	/RTPrintf("readdir: 'file'\n");/
296	return VINF_SUCCESS;
297	}
298	}
299	/else RTPrintf("%s: iDir=%d\n", pRealDir->iDir);/
300	}
301	return VERR_NO_MORE_FILES;
302	}
303
304	static uint64_t g_testRTDirSetMode_fMode;
305
306	extern int testRTDirSetMode(RTDIR hDir, RTFMODE fMode)
307	{
308	RT_NOREF1(hDir);
309	/* RTPrintf("%s: fMode=%llu\n", __PRETTY_FUNCTION__, LLUIFY(fMode)); */
310	g_testRTDirSetMode_fMode = fMode;
311	return VINF_SUCCESS;
312	}
313
314	static RTTIMESPEC g_testRTDirSetTimes_ATime;
315
316	extern int testRTDirSetTimes(RTDIR hDir, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
317	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
318	{
319	RT_NOREF4(hDir, pModificationTime, pChangeTime, pBirthTime);
320	/* RTPrintf("%s: hDir=%p, pAccessTime=%lli, pModificationTime=%lli, pChangeTime=%lli, pBirthTime=%lli\n",
321	__PRETTY_FUNCTION__, hDir,
322	pAccessTime ? (long long)RTTimeSpecGetNano(pAccessTime) : -1,
323	pModificationTime
324	? (long long)RTTimeSpecGetNano(pModificationTime) : -1,
325	pChangeTime ? (long long)RTTimeSpecGetNano(pChangeTime) : -1,
326	pBirthTime ? (long long)RTTimeSpecGetNano(pBirthTime) : -1); */
327	if (pAccessTime)
328	g_testRTDirSetTimes_ATime = *pAccessTime;
329	else
330	RT_ZERO(g_testRTDirSetTimes_ATime);
331	return VINF_SUCCESS;
332	}
333
334	static RTFILE g_testRTFileClose_hFile;
335
336	extern int testRTFileClose(RTFILE File)
337	{
338	/* RTPrintf("%s: File=%p\n", __PRETTY_FUNCTION__, File); */
339	g_testRTFileClose_hFile = File;
340	return 0;
341	}
342
343	extern int testRTFileDelete(const char *pszFilename)
344	{
345	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszFilename, "/\\")))
346	return VERR_FILE_NOT_FOUND;
347	RTPrintf("%s\n", __PRETTY_FUNCTION__);
348	return 0;
349	}
350
351	static RTFILE g_testRTFileFlush_hFile;
352
353	extern int testRTFileFlush(RTFILE File)
354	{
355	/* RTPrintf("%s: File=%p\n", __PRETTY_FUNCTION__, File); */
356	g_testRTFileFlush_hFile = File;
357	return VINF_SUCCESS;
358	}
359
360	static RTFILE g_testRTFileLock_hFile;
361	static unsigned g_testRTFileLock_fLock;
362	static int64_t g_testRTFileLock_offLock;
363	static uint64_t g_testRTFileLock_cbLock;
364
365	extern int testRTFileLock(RTFILE hFile, unsigned fLock, int64_t offLock, uint64_t cbLock)
366	{
367	/* RTPrintf("%s: hFile=%p, fLock=%u, offLock=%lli, cbLock=%llu\n",
368	__PRETTY_FUNCTION__, hFile, fLock, (long long) offLock,
369	LLUIFY(cbLock)); */
370	g_testRTFileLock_hFile = hFile;
371	g_testRTFileLock_fLock = fLock;
372	g_testRTFileLock_offLock = offLock;
373	g_testRTFileLock_cbLock = cbLock;
374	return VINF_SUCCESS;
375	}
376
377	static char g_testRTFileOpen_szName[256];
378	static uint64_t g_testRTFileOpen_fOpen;
379	static RTFILE g_testRTFileOpen_hFile;
380
381	extern int testRTFileOpenEx(const char *pszFilename, uint64_t fOpen, PRTFILE phFile, PRTFILEACTION penmActionTaken)
382	{
383	/* RTPrintf("%s, pszFilename=%s, fOpen=0x%llx\n", __PRETTY_FUNCTION__,
384	pszFilename, LLUIFY(fOpen)); */
385	ARRAY_FROM_PATH(g_testRTFileOpen_szName, pszFilename);
386	g_testRTFileOpen_fOpen = fOpen;
387	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszFilename, "/\\")))
388	return VERR_FILE_NOT_FOUND;
389	*phFile = g_testRTFileOpen_hFile;
390	*penmActionTaken = RTFILEACTION_CREATED;
391	g_testRTFileOpen_hFile = 0;
392	return VINF_SUCCESS;
393	}
394
395	static RTFILE g_testRTFileQueryInfo_hFile;
396	static RTTIMESPEC g_testRTFileQueryInfo_ATime;
397	static uint32_t g_testRTFileQueryInfo_fMode;
398
399	extern int testRTFileQueryInfo(RTFILE hFile, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
400	{
401	RT_NOREF1(enmAdditionalAttribs);
402	/* RTPrintf("%s, hFile=%p, enmAdditionalAttribs=0x%llx\n",
403	__PRETTY_FUNCTION__, hFile, LLUIFY(enmAdditionalAttribs)); */
404	g_testRTFileQueryInfo_hFile = hFile;
405	RT_ZERO(*pObjInfo);
406	pObjInfo->AccessTime = g_testRTFileQueryInfo_ATime;
407	RT_ZERO(g_testRTDirQueryInfo_ATime);
408	pObjInfo->Attr.fMode = g_testRTFileQueryInfo_fMode;
409	g_testRTFileQueryInfo_fMode = 0;
410	return VINF_SUCCESS;
411	}
412
413	static const char *g_testRTFileRead_pszData;
414
415	extern int testRTFileRead(RTFILE File, void pvBuf, size_t cbToRead, size_t pcbRead)
416	{
417	RT_NOREF1(File);
418	/* RTPrintf("%s : File=%p, cbToRead=%llu\n", __PRETTY_FUNCTION__, File,
419	LLUIFY(cbToRead)); */
420	bufferFromPath((char *)pvBuf, cbToRead, g_testRTFileRead_pszData);
421	if (pcbRead)
422	*pcbRead = RT_MIN(cbToRead, strlen(g_testRTFileRead_pszData) + 1);
423	g_testRTFileRead_pszData = 0;
424	return VINF_SUCCESS;
425	}
426
427	extern int testRTFileReadAt(RTFILE hFile, uint64_t offFile, void pvBuf, size_t cbToRead, size_t pcbRead)
428	{
429	RT_NOREF1(hFile);
430	RT_NOREF(offFile);
431	/* RTPrintf("%s : File=%p, cbToRead=%llu\n", __PRETTY_FUNCTION__, File,
432	LLUIFY(cbToRead)); */
433	bufferFromPath((char *)pvBuf, cbToRead, g_testRTFileRead_pszData);
434	if (pcbRead)
435	*pcbRead = RT_MIN(cbToRead, strlen(g_testRTFileRead_pszData) + 1);
436	g_testRTFileRead_pszData = 0;
437	return VINF_SUCCESS;
438	}
439
440	extern int testRTFileSeek(RTFILE hFile, int64_t offSeek, unsigned uMethod, uint64_t *poffActual)
441	{
442	RT_NOREF3(hFile, offSeek, uMethod);
443	/* RTPrintf("%s : hFile=%p, offSeek=%llu, uMethod=%u\n", __PRETTY_FUNCTION__,
444	hFile, LLUIFY(offSeek), uMethod); */
445	if (poffActual)
446	*poffActual = 0;
447	return VINF_SUCCESS;
448	}
449
450	static uint64_t g_testRTFileSet_fMode;
451
452	extern int testRTFileSetMode(RTFILE File, RTFMODE fMode)
453	{
454	RT_NOREF1(File);
455	/* RTPrintf("%s: fMode=%llu\n", __PRETTY_FUNCTION__, LLUIFY(fMode)); */
456	g_testRTFileSet_fMode = fMode;
457	return VINF_SUCCESS;
458	}
459
460	static RTFILE g_testRTFileSetSize_hFile;
461	static RTFOFF g_testRTFileSetSize_cbSize;
462
463	extern int testRTFileSetSize(RTFILE File, uint64_t cbSize)
464	{
465	/* RTPrintf("%s: File=%llu, cbSize=%llu\n", __PRETTY_FUNCTION__, LLUIFY(File),
466	LLUIFY(cbSize)); */
467	g_testRTFileSetSize_hFile = File;
468	g_testRTFileSetSize_cbSize = (RTFOFF) cbSize; /* Why was this signed before? */
469	return VINF_SUCCESS;
470	}
471
472	static RTTIMESPEC g_testRTFileSetTimes_ATime;
473
474	extern int testRTFileSetTimes(RTFILE File, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
475	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
476	{
477	RT_NOREF4(File, pModificationTime, pChangeTime, pBirthTime);
478	/* RTPrintf("%s: pFile=%p, pAccessTime=%lli, pModificationTime=%lli, pChangeTime=%lli, pBirthTime=%lli\n",
479	__PRETTY_FUNCTION__,
480	pAccessTime ? (long long)RTTimeSpecGetNano(pAccessTime) : -1,
481	pModificationTime
482	? (long long)RTTimeSpecGetNano(pModificationTime) : -1,
483	pChangeTime ? (long long)RTTimeSpecGetNano(pChangeTime) : -1,
484	pBirthTime ? (long long)RTTimeSpecGetNano(pBirthTime) : -1); */
485	if (pAccessTime)
486	g_testRTFileSetTimes_ATime = *pAccessTime;
487	else
488	RT_ZERO(g_testRTFileSetTimes_ATime);
489	return VINF_SUCCESS;
490	}
491
492	static RTFILE g_testRTFileUnlock_hFile;
493	static int64_t g_testRTFileUnlock_offLock;
494	static uint64_t g_testRTFileUnlock_cbLock;
495
496	extern int testRTFileUnlock(RTFILE File, int64_t offLock, uint64_t cbLock)
497	{
498	/* RTPrintf("%s: hFile=%p, ofLock=%lli, cbLock=%llu\n", __PRETTY_FUNCTION__,
499	File, (long long) offLock, LLUIFY(cbLock)); */
500	g_testRTFileUnlock_hFile = File;
501	g_testRTFileUnlock_offLock = offLock;
502	g_testRTFileUnlock_cbLock = cbLock;
503	return VINF_SUCCESS;
504	}
505
506	static char g_testRTFileWrite_szData[256];
507
508	extern int testRTFileWrite(RTFILE File, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
509	{
510	RT_NOREF2(File, cbToWrite);
511	/* RTPrintf("%s: File=%p, pvBuf=%.*s, cbToWrite=%llu\n", __PRETTY_FUNCTION__,
512	File, cbToWrite, (const char )pvBuf, LLUIFY(cbToWrite)); /
513	ARRAY_FROM_PATH(g_testRTFileWrite_szData, (const char *)pvBuf);
514	if (pcbWritten)
515	*pcbWritten = strlen(g_testRTFileWrite_szData) + 1;
516	return VINF_SUCCESS;
517	}
518
519	extern int testRTFileWriteAt(RTFILE File, uint64_t offFile, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
520	{
521	RT_NOREF3(File, cbToWrite, offFile);
522	/* RTPrintf("%s: File=%p, pvBuf=%.*s, cbToWrite=%llu\n", __PRETTY_FUNCTION__,
523	File, cbToWrite, (const char )pvBuf, LLUIFY(cbToWrite)); /
524	ARRAY_FROM_PATH(g_testRTFileWrite_szData, (const char *)pvBuf);
525	if (pcbWritten)
526	*pcbWritten = strlen(g_testRTFileWrite_szData) + 1;
527	return VINF_SUCCESS;
528	}
529
530	extern int testRTFsQueryProperties(const char *pszFsPath, PRTFSPROPERTIES pProperties)
531	{
532	RT_NOREF1(pszFsPath);
533	/* RTPrintf("%s, pszFsPath=%s\n", __PRETTY_FUNCTION__, pszFsPath);
534	RT_ZERO(pProperties); /
535	pProperties->cbMaxComponent = 256;
536	pProperties->fCaseSensitive = true;
537	return VINF_SUCCESS;
538	}
539
540	extern int testRTFsQuerySerial(const char pszFsPath, uint32_t pu32Serial)
541	{
542	RT_NOREF2(pszFsPath, pu32Serial);
543	RTPrintf("%s\n", __PRETTY_FUNCTION__);
544	return 0;
545	}
546	extern int testRTFsQuerySizes(const char pszFsPath, PRTFOFF pcbTotal, RTFOFF pcbFree, uint32_t pcbBlock, uint32_t pcbSector)
547	{
548	RT_NOREF5(pszFsPath, pcbTotal, pcbFree, pcbBlock, pcbSector);
549	RTPrintf("%s\n", __PRETTY_FUNCTION__);
550	return 0;
551	}
552
553	extern int testRTPathQueryInfoEx(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
554	{
555	RT_NOREF2(enmAdditionalAttribs, fFlags);
556	/* RTPrintf("%s: pszPath=%s, enmAdditionalAttribs=0x%x, fFlags=0x%x\n",
557	__PRETTY_FUNCTION__, pszPath, (unsigned) enmAdditionalAttribs,
558	(unsigned) fFlags); */
559	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
560	return VERR_FILE_NOT_FOUND;
561	RT_ZERO(*pObjInfo);
562	return VINF_SUCCESS;
563	}
564
565	extern int testRTSymlinkDelete(const char *pszSymlink, uint32_t fDelete)
566	{
567	RT_NOREF2(pszSymlink, fDelete);
568	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszSymlink, "/\\")))
569	return VERR_FILE_NOT_FOUND;
570	RTPrintf("%s\n", __PRETTY_FUNCTION__);
571	return 0;
572	}
573
574	extern int testRTSymlinkRead(const char pszSymlink, char pszTarget, size_t cbTarget, uint32_t fRead)
575	{
576	if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszSymlink, "/\\")))
577	return VERR_FILE_NOT_FOUND;
578	RT_NOREF4(pszSymlink, pszTarget, cbTarget, fRead);
579	RTPrintf("%s\n", __PRETTY_FUNCTION__);
580	return 0;
581	}
582
583
584	/*********************************************************************************************************************************
585	* Tests *
586	*********************************************************************************************************************************/
587
588	/* Sub-tests for testMappingsQuery(). */
589	void testMappingsQuerySimple(RTTEST hTest) { RT_NOREF1(hTest); }
590	void testMappingsQueryTooFewBuffers(RTTEST hTest) { RT_NOREF1(hTest); }
591	void testMappingsQueryAutoMount(RTTEST hTest) { RT_NOREF1(hTest); }
592	void testMappingsQueryArrayWrongSize(RTTEST hTest) { RT_NOREF1(hTest); }
593
594	/* Sub-tests for testMappingsQueryName(). */
595	void testMappingsQueryNameValid(RTTEST hTest) { RT_NOREF1(hTest); }
596	void testMappingsQueryNameInvalid(RTTEST hTest) { RT_NOREF1(hTest); }
597	void testMappingsQueryNameBadBuffer(RTTEST hTest) { RT_NOREF1(hTest); }
598
599	/* Sub-tests for testMapFolder(). */
600	void testMapFolderValid(RTTEST hTest) { RT_NOREF1(hTest); }
601	void testMapFolderInvalid(RTTEST hTest) { RT_NOREF1(hTest); }
602	void testMapFolderTwice(RTTEST hTest) { RT_NOREF1(hTest); }
603	void testMapFolderDelimiter(RTTEST hTest) { RT_NOREF1(hTest); }
604	void testMapFolderCaseSensitive(RTTEST hTest) { RT_NOREF1(hTest); }
605	void testMapFolderCaseInsensitive(RTTEST hTest) { RT_NOREF1(hTest); }
606	void testMapFolderBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
607
608	/* Sub-tests for testUnmapFolder(). */
609	void testUnmapFolderValid(RTTEST hTest) { RT_NOREF1(hTest); }
610	void testUnmapFolderInvalid(RTTEST hTest) { RT_NOREF1(hTest); }
611	void testUnmapFolderBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
612
613	/* Sub-tests for testCreate(). */
614	void testCreateBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
615
616	/* Sub-tests for testClose(). */
617	void testCloseBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
618
619	/* Sub-tests for testRead(). */
620	void testReadBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
621
622	/* Sub-tests for testWrite(). */
623	void testWriteBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
624
625	/* Sub-tests for testLock(). */
626	void testLockBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
627
628	/* Sub-tests for testFlush(). */
629	void testFlushBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
630
631	/* Sub-tests for testDirList(). */
632	void testDirListBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
633
634	/* Sub-tests for testReadLink(). */
635	void testReadLinkBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
636
637	/* Sub-tests for testFSInfo(). */
638	void testFSInfoBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
639
640	/* Sub-tests for testRemove(). */
641	void testRemoveBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
642
643	/* Sub-tests for testRename(). */
644	void testRenameBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
645
646	/* Sub-tests for testSymlink(). */
647	void testSymlinkBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
648
649	/* Sub-tests for testMappingsAdd(). */
650	void testMappingsAddBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
651
652	/* Sub-tests for testMappingsRemove(). */
653	void testMappingsRemoveBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
654
655	union TESTSHFLSTRING
656	{
657	SHFLSTRING string;
658	char acData[256];
659	};
660
661	static void fillTestShflString(union TESTSHFLSTRING *pDest,
662	const char *pcszSource)
663	{
664	const size_t cchSource = strlen(pcszSource);
665	AssertRelease( cchSource * 2 + 2
666	< sizeof(*pDest) - RT_UOFFSETOF(SHFLSTRING, String));
667	pDest->string.u16Length = (uint16_t)(cchSource * sizeof(RTUTF16));
668	pDest->string.u16Size = pDest->string.u16Length + sizeof(RTUTF16);
669	/* Copy pcszSource ASCIIZ, including the trailing 0, to the UTF16 pDest->string.String.ucs2. */
670	for (unsigned i = 0; i <= cchSource; ++i)
671	pDest->string.String.ucs2[i] = (uint16_t)pcszSource[i];
672	}
673
674	static SHFLROOT initWithWritableMapping(RTTEST hTest,
675	VBOXHGCMSVCFNTABLE *psvcTable,
676	VBOXHGCMSVCHELPERS *psvcHelpers,
677	const char *pcszFolderName,
678	const char *pcszMapping,
679	bool fCaseSensitive = true)
680	{
681	VBOXHGCMSVCPARM aParms[RT_MAX(SHFL_CPARMS_ADD_MAPPING,
682	SHFL_CPARMS_MAP_FOLDER)];
683	union TESTSHFLSTRING FolderName;
684	union TESTSHFLSTRING Mapping;
685	union TESTSHFLSTRING AutoMountPoint;
686	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
687	int rc;
688
689	initTable(psvcTable, psvcHelpers);
690	AssertReleaseRC(VBoxHGCMSvcLoad(psvcTable));
691	AssertRelease( psvcTable->pvService
692	= RTTestGuardedAllocTail(hTest, psvcTable->cbClient));
693	RT_BZERO(psvcTable->pvService, psvcTable->cbClient);
694	fillTestShflString(&FolderName, pcszFolderName);
695	fillTestShflString(&Mapping, pcszMapping);
696	fillTestShflString(&AutoMountPoint, "");
697	HGCMSvcSetPv(&aParms[0], &FolderName, RT_UOFFSETOF(SHFLSTRING, String)
698	+ FolderName.string.u16Size);
699	HGCMSvcSetPv(&aParms[1], &Mapping, RT_UOFFSETOF(SHFLSTRING, String)
700	+ Mapping.string.u16Size);
701	HGCMSvcSetU32(&aParms[2], 1);
702	HGCMSvcSetPv(&aParms[3], &AutoMountPoint, SHFLSTRING_HEADER_SIZE + AutoMountPoint.string.u16Size);
703	rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_ADD_MAPPING,
704	SHFL_CPARMS_ADD_MAPPING, aParms);
705	AssertReleaseRC(rc);
706	HGCMSvcSetPv(&aParms[0], &Mapping, RT_UOFFSETOF(SHFLSTRING, String)
707	+ Mapping.string.u16Size);
708	HGCMSvcSetU32(&aParms[1], 0); /* root */
709	HGCMSvcSetU32(&aParms[2], '/'); /* delimiter */
710	HGCMSvcSetU32(&aParms[3], fCaseSensitive);
711	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
712	psvcTable->pvService, SHFL_FN_MAP_FOLDER,
713	SHFL_CPARMS_MAP_FOLDER, aParms, 0);
714	AssertReleaseRC(callHandle.rc);
715	return aParms[1].u.uint32;
716	}
717
718	/** @todo Mappings should be automatically removed by unloading the service,
719	* but unloading is currently a no-op! */
720	static void unmapAndRemoveMapping(RTTEST hTest, VBOXHGCMSVCFNTABLE *psvcTable,
721	SHFLROOT root, const char *pcszFolderName)
722	{
723	RT_NOREF1(hTest);
724	VBOXHGCMSVCPARM aParms[RT_MAX(SHFL_CPARMS_UNMAP_FOLDER,
725	SHFL_CPARMS_REMOVE_MAPPING)];
726	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
727	union TESTSHFLSTRING FolderName;
728	int rc;
729
730	HGCMSvcSetU32(&aParms[0], root);
731	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
732	psvcTable->pvService, SHFL_FN_UNMAP_FOLDER,
733	SHFL_CPARMS_UNMAP_FOLDER, aParms, 0);
734	AssertReleaseRC(callHandle.rc);
735	fillTestShflString(&FolderName, pcszFolderName);
736	HGCMSvcSetPv(&aParms[0], &FolderName, RT_UOFFSETOF(SHFLSTRING, String)
737	+ FolderName.string.u16Size);
738	rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_REMOVE_MAPPING,
739	SHFL_CPARMS_REMOVE_MAPPING, aParms);
740	AssertReleaseRC(rc);
741	}
742
743	static int createFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT Root,
744	const char *pcszFilename, uint32_t fCreateFlags,
745	SHFLHANDLE pHandle, SHFLCREATERESULT pResult)
746	{
747	VBOXHGCMSVCPARM aParms[SHFL_CPARMS_CREATE];
748	union TESTSHFLSTRING Path;
749	SHFLCREATEPARMS CreateParms;
750	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
751
752	fillTestShflString(&Path, pcszFilename);
753	RT_ZERO(CreateParms);
754	CreateParms.CreateFlags = fCreateFlags;
755	HGCMSvcSetU32(&aParms[0], Root);
756	HGCMSvcSetPv(&aParms[1], &Path, RT_UOFFSETOF(SHFLSTRING, String)
757	+ Path.string.u16Size);
758	HGCMSvcSetPv(&aParms[2], &CreateParms, sizeof(CreateParms));
759	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
760	psvcTable->pvService, SHFL_FN_CREATE,
761	RT_ELEMENTS(aParms), aParms, 0);
762	if (RT_FAILURE(callHandle.rc))
763	return callHandle.rc;
764	if (pHandle)
765	*pHandle = CreateParms.Handle;
766	if (pResult)
767	*pResult = CreateParms.Result;
768	return VINF_SUCCESS;
769	}
770
771	static int readFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT Root,
772	SHFLHANDLE hFile, uint64_t offSeek, uint32_t cbRead,
773	uint32_t pcbRead, void pvBuf, uint32_t cbBuf)
774	{
775	VBOXHGCMSVCPARM aParms[SHFL_CPARMS_READ];
776	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
777
778	HGCMSvcSetU32(&aParms[0], Root);
779	HGCMSvcSetU64(&aParms[1], (uint64_t) hFile);
780	HGCMSvcSetU64(&aParms[2], offSeek);
781	HGCMSvcSetU32(&aParms[3], cbRead);
782	HGCMSvcSetPv(&aParms[4], pvBuf, cbBuf);
783	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
784	psvcTable->pvService, SHFL_FN_READ,
785	RT_ELEMENTS(aParms), aParms, 0);
786	if (pcbRead)
787	*pcbRead = aParms[3].u.uint32;
788	return callHandle.rc;
789	}
790
791	static int writeFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT Root,
792	SHFLHANDLE hFile, uint64_t offSeek, uint32_t cbWrite,
793	uint32_t pcbWritten, const void pvBuf, uint32_t cbBuf)
794	{
795	VBOXHGCMSVCPARM aParms[SHFL_CPARMS_WRITE];
796	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
797
798	HGCMSvcSetU32(&aParms[0], Root);
799	HGCMSvcSetU64(&aParms[1], (uint64_t) hFile);
800	HGCMSvcSetU64(&aParms[2], offSeek);
801	HGCMSvcSetU32(&aParms[3], cbWrite);
802	HGCMSvcSetPv(&aParms[4], (void *)pvBuf, cbBuf);
803	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
804	psvcTable->pvService, SHFL_FN_WRITE,
805	RT_ELEMENTS(aParms), aParms, 0);
806	if (pcbWritten)
807	*pcbWritten = aParms[3].u.uint32;
808	return callHandle.rc;
809	}
810
811	static int flushFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT root,
812	SHFLHANDLE handle)
813	{
814	VBOXHGCMSVCPARM aParms[SHFL_CPARMS_FLUSH];
815	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
816
817	HGCMSvcSetU32(&aParms[0], root);
818	HGCMSvcSetU64(&aParms[1], handle);
819	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
820	psvcTable->pvService, SHFL_FN_FLUSH,
821	SHFL_CPARMS_FLUSH, aParms, 0);
822	return callHandle.rc;
823	}
824
825	static int listDir(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT root,
826	SHFLHANDLE handle, uint32_t fFlags,
827	const char pcszPath, void pvBuf, uint32_t cbBuf,
828	uint32_t resumePoint, uint32_t *pcFiles)
829	{
830	VBOXHGCMSVCPARM aParms[SHFL_CPARMS_LIST];
831	union TESTSHFLSTRING Path;
832	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
833
834	HGCMSvcSetU32(&aParms[0], root);
835	HGCMSvcSetU64(&aParms[1], handle);
836	HGCMSvcSetU32(&aParms[2], fFlags);
837	HGCMSvcSetU32(&aParms[3], cbBuf);
838	if (pcszPath)
839	{
840	fillTestShflString(&Path, pcszPath);
841	HGCMSvcSetPv(&aParms[4], &Path, RT_UOFFSETOF(SHFLSTRING, String)
842	+ Path.string.u16Size);
843	}
844	else
845	HGCMSvcSetPv(&aParms[4], NULL, 0);
846	HGCMSvcSetPv(&aParms[5], pvBuf, cbBuf);
847	HGCMSvcSetU32(&aParms[6], resumePoint);
848	HGCMSvcSetU32(&aParms[7], 0);
849	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
850	psvcTable->pvService, SHFL_FN_LIST,
851	RT_ELEMENTS(aParms), aParms, 0);
852	if (pcFiles)
853	*pcFiles = aParms[7].u.uint32;
854	return callHandle.rc;
855	}
856
857	static int sfInformation(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT root,
858	SHFLHANDLE handle, uint32_t fFlags, uint32_t cb,
859	SHFLFSOBJINFO *pInfo)
860	{
861	VBOXHGCMSVCPARM aParms[SHFL_CPARMS_INFORMATION];
862	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
863
864	HGCMSvcSetU32(&aParms[0], root);
865	HGCMSvcSetU64(&aParms[1], handle);
866	HGCMSvcSetU32(&aParms[2], fFlags);
867	HGCMSvcSetU32(&aParms[3], cb);
868	HGCMSvcSetPv(&aParms[4], pInfo, cb);
869	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
870	psvcTable->pvService, SHFL_FN_INFORMATION,
871	RT_ELEMENTS(aParms), aParms, 0);
872	return callHandle.rc;
873	}
874
875	static int lockFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT root,
876	SHFLHANDLE handle, int64_t offLock, uint64_t cbLock,
877	uint32_t fFlags)
878	{
879	VBOXHGCMSVCPARM aParms[SHFL_CPARMS_LOCK];
880	VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
881
882	HGCMSvcSetU32(&aParms[0], root);
883	HGCMSvcSetU64(&aParms[1], handle);
884	HGCMSvcSetU64(&aParms[2], offLock);
885	HGCMSvcSetU64(&aParms[3], cbLock);
886	HGCMSvcSetU32(&aParms[4], fFlags);
887	psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
888	psvcTable->pvService, SHFL_FN_LOCK,
889	RT_ELEMENTS(aParms), aParms, 0);
890	return callHandle.rc;
891	}
892
893	void testCreateFileSimple(RTTEST hTest)
894	{
895	VBOXHGCMSVCFNTABLE svcTable;
896	VBOXHGCMSVCHELPERS svcHelpers;
897	SHFLROOT Root;
898	const RTFILE hFile = (RTFILE) 0x10000;
899	SHFLCREATERESULT Result;
900	int rc;
901
902	RTTestSub(hTest, "Create file simple");
903	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
904	"/test/mapping", "testname");
905	g_testRTFileOpen_hFile = hFile;
906	rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ, NULL,
907	&Result);
908	RTTEST_CHECK_RC_OK(hTest, rc);
909	RTTEST_CHECK_MSG(hTest,
910	!strcmp(&g_testRTFileOpen_szName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0],
911	"/test/mapping/test/file"),
912	(hTest, "pszFilename=%s\n", &g_testRTFileOpen_szName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0]));
913	RTTEST_CHECK_MSG(hTest, g_testRTFileOpen_fOpen == 0x181,
914	(hTest, "fOpen=%llu\n", LLUIFY(g_testRTFileOpen_fOpen)));
915	RTTEST_CHECK_MSG(hTest, Result == SHFL_FILE_CREATED,
916	(hTest, "Result=%d\n", (int) Result));
917	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
918	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
919	AssertReleaseRC(svcTable.pfnUnload(NULL));
920	RTTestGuardedFree(hTest, svcTable.pvService);
921	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile,
922	(hTest, "File=%u\n", (uintptr_t)g_testRTFileClose_hFile));
923	}
924
925	void testCreateFileSimpleCaseInsensitive(RTTEST hTest)
926	{
927	VBOXHGCMSVCFNTABLE svcTable;
928	VBOXHGCMSVCHELPERS svcHelpers;
929	SHFLROOT Root;
930	const RTFILE hFile = (RTFILE) 0x10000;
931	SHFLCREATERESULT Result;
932	int rc;
933
934	g_fFailIfNotLowercase = true;
935
936	RTTestSub(hTest, "Create file case insensitive");
937	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
938	"/test/mapping", "testname", false /fCaseSensitive/);
939	g_testRTFileOpen_hFile = hFile;
940	rc = createFile(&svcTable, Root, "/TesT/FilE", SHFL_CF_ACCESS_READ, NULL,
941	&Result);
942	RTTEST_CHECK_RC_OK(hTest, rc);
943
944	RTTEST_CHECK_MSG(hTest,
945	!strcmp(&g_testRTFileOpen_szName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0],
946	"/test/mapping/test/file"),
947	(hTest, "pszFilename=%s\n", &g_testRTFileOpen_szName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0]));
948	RTTEST_CHECK_MSG(hTest, g_testRTFileOpen_fOpen == 0x181,
949	(hTest, "fOpen=%llu\n", LLUIFY(g_testRTFileOpen_fOpen)));
950	RTTEST_CHECK_MSG(hTest, Result == SHFL_FILE_CREATED,
951	(hTest, "Result=%d\n", (int) Result));
952	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
953	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
954	AssertReleaseRC(svcTable.pfnUnload(NULL));
955	RTTestGuardedFree(hTest, svcTable.pvService);
956	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile,
957	(hTest, "File=%u\n", (uintptr_t)g_testRTFileClose_hFile));
958
959	g_fFailIfNotLowercase = false;
960	}
961
962	void testCreateDirSimple(RTTEST hTest)
963	{
964	VBOXHGCMSVCFNTABLE svcTable;
965	VBOXHGCMSVCHELPERS svcHelpers;
966	SHFLROOT Root;
967	RTDIR hDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
968	SHFLCREATERESULT Result;
969	int rc;
970
971	RTTestSub(hTest, "Create directory simple");
972	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
973	"/test/mapping", "testname");
974	g_testRTDirOpen_hDir = hDir;
975	rc = createFile(&svcTable, Root, "test/dir",
976	SHFL_CF_DIRECTORY \| SHFL_CF_ACCESS_READ, NULL, &Result);
977	RTTEST_CHECK_RC_OK(hTest, rc);
978	RTTEST_CHECK_MSG(hTest,
979	!strcmp(&g_testRTDirCreate_szPath[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0],
980	"/test/mapping/test/dir"),
981	(hTest, "pszPath=%s\n", &g_testRTDirCreate_szPath[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0]));
982	RTTEST_CHECK_MSG(hTest,
983	!strcmp(&g_testRTDirOpen_szName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0],
984	"/test/mapping/test/dir"),
985	(hTest, "pszFilename=%s\n", &g_testRTDirOpen_szName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0]));
986	RTTEST_CHECK_MSG(hTest, Result == SHFL_FILE_CREATED,
987	(hTest, "Result=%d\n", (int) Result));
988	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
989	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
990	AssertReleaseRC(svcTable.pfnUnload(NULL));
991	RTTestGuardedFree(hTest, svcTable.pvService);
992	RTTEST_CHECK_MSG(hTest, g_testRTDirClose_hDir == hDir, (hTest, "hDir=%p\n", g_testRTDirClose_hDir));
993	}
994
995	void testReadFileSimple(RTTEST hTest)
996	{
997	VBOXHGCMSVCFNTABLE svcTable;
998	VBOXHGCMSVCHELPERS svcHelpers;
999	SHFLROOT Root;
1000	const RTFILE hFile = (RTFILE) 0x10000;
1001	SHFLHANDLE Handle;
1002	const char *pcszReadData = "Data to read";
1003	char achBuf[sizeof(pcszReadData) + 10];
1004	uint32_t cbRead;
1005	int rc;
1006
1007	RTTestSub(hTest, "Read file simple");
1008	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1009	"/test/mapping", "testname");
1010	g_testRTFileOpen_hFile = hFile;
1011	rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
1012	&Handle, NULL);
1013	RTTEST_CHECK_RC_OK(hTest, rc);
1014	g_testRTFileRead_pszData = pcszReadData;
1015	memset(achBuf, 'f', sizeof(achBuf));
1016	rc = readFile(&svcTable, Root, Handle, 0, (uint32_t)strlen(pcszReadData) + 1,
1017	&cbRead, achBuf, (uint32_t)sizeof(achBuf));
1018	RTTEST_CHECK_RC_OK(hTest, rc);
1019	RTTEST_CHECK_MSG(hTest,
1020	!strncmp(achBuf, pcszReadData, sizeof(achBuf)),
1021	(hTest, "pvBuf=%.*s Handle=%#RX64\n", sizeof(achBuf), achBuf, Handle));
1022	RTTEST_CHECK_MSG(hTest, cbRead == strlen(pcszReadData) + 1,
1023	(hTest, "cbRead=%llu\n", LLUIFY(cbRead)));
1024	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1025	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile, (hTest, "File=%u\n", g_testRTFileClose_hFile));
1026	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1027	AssertReleaseRC(svcTable.pfnUnload(NULL));
1028	RTTestGuardedFree(hTest, svcTable.pvService);
1029	}
1030
1031	void testWriteFileSimple(RTTEST hTest)
1032	{
1033	VBOXHGCMSVCFNTABLE svcTable;
1034	VBOXHGCMSVCHELPERS svcHelpers;
1035	SHFLROOT Root;
1036	const RTFILE hFile = (RTFILE) 0x10000;
1037	SHFLHANDLE Handle;
1038	const char *pcszWrittenData = "Data to write";
1039	uint32_t cbToWrite = (uint32_t)strlen(pcszWrittenData) + 1;
1040	uint32_t cbWritten;
1041	int rc;
1042
1043	RTTestSub(hTest, "Write file simple");
1044	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1045	"/test/mapping", "testname");
1046	g_testRTFileOpen_hFile = hFile;
1047	rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
1048	&Handle, NULL);
1049	RTTEST_CHECK_RC_OK(hTest, rc);
1050	rc = writeFile(&svcTable, Root, Handle, 0, cbToWrite, &cbWritten,
1051	pcszWrittenData, cbToWrite);
1052	RTTEST_CHECK_RC_OK(hTest, rc);
1053	RTTEST_CHECK_MSG(hTest,
1054	!strcmp(g_testRTFileWrite_szData, pcszWrittenData),
1055	(hTest, "pvBuf=%s\n", g_testRTFileWrite_szData));
1056	RTTEST_CHECK_MSG(hTest, cbWritten == cbToWrite,
1057	(hTest, "cbWritten=%llu\n", LLUIFY(cbWritten)));
1058	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1059	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile, (hTest, "File=%u\n", g_testRTFileClose_hFile));
1060	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1061	AssertReleaseRC(svcTable.pfnUnload(NULL));
1062	RTTestGuardedFree(hTest, svcTable.pvService);
1063	}
1064
1065	void testFlushFileSimple(RTTEST hTest)
1066	{
1067	VBOXHGCMSVCFNTABLE svcTable;
1068	VBOXHGCMSVCHELPERS svcHelpers;
1069	SHFLROOT Root;
1070	const RTFILE hFile = (RTFILE) 0x10000;
1071	SHFLHANDLE Handle;
1072	int rc;
1073
1074	RTTestSub(hTest, "Flush file simple");
1075	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1076	"/test/mapping", "testname");
1077	g_testRTFileOpen_hFile = hFile;
1078	rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
1079	&Handle, NULL);
1080	RTTEST_CHECK_RC_OK(hTest, rc);
1081	rc = flushFile(&svcTable, Root, Handle);
1082	RTTEST_CHECK_RC_OK(hTest, rc);
1083	RTTEST_CHECK_MSG(hTest, g_testRTFileFlush_hFile == hFile, (hTest, "File=%u\n", g_testRTFileFlush_hFile));
1084	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1085	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1086	AssertReleaseRC(svcTable.pfnUnload(NULL));
1087	RTTestGuardedFree(hTest, svcTable.pvService);
1088	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile, (hTest, "File=%u\n", g_testRTFileClose_hFile));
1089	}
1090
1091	void testDirListEmpty(RTTEST hTest)
1092	{
1093	VBOXHGCMSVCFNTABLE svcTable;
1094	VBOXHGCMSVCHELPERS svcHelpers;
1095	SHFLROOT Root;
1096	RTDIR hDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
1097	SHFLHANDLE Handle;
1098	union
1099	{
1100	SHFLDIRINFO DirInfo;
1101	uint8_t abBuffer[sizeof(SHFLDIRINFO) + 2 * sizeof(RTUTF16)];
1102	} Buf;
1103	uint32_t cFiles;
1104	int rc;
1105
1106	RTTestSub(hTest, "List empty directory");
1107	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1108	"/test/mapping", "testname");
1109	g_testRTDirOpen_hDir = hDir;
1110	rc = createFile(&svcTable, Root, "test/dir",
1111	SHFL_CF_DIRECTORY \| SHFL_CF_ACCESS_READ, &Handle, NULL);
1112	RTTEST_CHECK_RC_OK(hTest, rc);
1113	rc = listDir(&svcTable, Root, Handle, 0, NULL, &Buf.DirInfo, sizeof(Buf), 0, &cFiles);
1114	RTTEST_CHECK_RC(hTest, rc, VERR_NO_MORE_FILES);
1115	RTTEST_CHECK_MSG(hTest, g_testRTDirReadEx_hDir == hDir, (hTest, "Dir=%p\n", g_testRTDirReadEx_hDir));
1116	RTTEST_CHECK_MSG(hTest, cFiles == 0,
1117	(hTest, "cFiles=%llu\n", LLUIFY(cFiles)));
1118	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1119	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1120	AssertReleaseRC(svcTable.pfnUnload(NULL));
1121	RTTestGuardedFree(hTest, svcTable.pvService);
1122	RTTEST_CHECK_MSG(hTest, g_testRTDirClose_hDir == hDir, (hTest, "hDir=%p\n", g_testRTDirClose_hDir));
1123	}
1124
1125	void testFSInfoQuerySetFMode(RTTEST hTest)
1126	{
1127	VBOXHGCMSVCFNTABLE svcTable;
1128	VBOXHGCMSVCHELPERS svcHelpers;
1129	SHFLROOT Root;
1130	const RTFILE hFile = (RTFILE) 0x10000;
1131	const uint32_t fMode = 0660;
1132	SHFLFSOBJINFO Info;
1133	int rc;
1134
1135	RTTestSub(hTest, "Query and set file size");
1136	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1137	"/test/mapping", "testname");
1138	SHFLHANDLE Handle = SHFL_HANDLE_NIL;
1139	g_testRTFileOpen_hFile = hFile;
1140	rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
1141	&Handle, NULL);
1142	RTTEST_CHECK_RC_OK_RETV(hTest, rc);
1143
1144	RT_ZERO(Info);
1145	g_testRTFileQueryInfo_fMode = fMode;
1146	rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_FILE, sizeof(Info),
1147	&Info);
1148	RTTEST_CHECK_RC_OK(hTest, rc);
1149	RTTEST_CHECK_MSG(hTest, g_testRTFileQueryInfo_hFile == hFile, (hTest, "File=%u\n", g_testRTFileQueryInfo_hFile));
1150	RTTEST_CHECK_MSG(hTest, Info.Attr.fMode == fMode,
1151	(hTest, "cbObject=%llu\n", LLUIFY(Info.cbObject)));
1152	RT_ZERO(Info);
1153	Info.Attr.fMode = fMode;
1154	rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET \| SHFL_INFO_FILE,
1155	sizeof(Info), &Info);
1156	RTTEST_CHECK_RC_OK(hTest, rc);
1157	RTTEST_CHECK_MSG(hTest, g_testRTFileSet_fMode == fMode,
1158	(hTest, "Size=%llu\n", LLUIFY(g_testRTFileSet_fMode)));
1159	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1160	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1161	AssertReleaseRC(svcTable.pfnUnload(NULL));
1162	RTTestGuardedFree(hTest, svcTable.pvService);
1163	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile, (hTest, "File=%u\n", g_testRTFileClose_hFile));
1164	}
1165
1166	void testFSInfoQuerySetDirATime(RTTEST hTest)
1167	{
1168	VBOXHGCMSVCFNTABLE svcTable;
1169	VBOXHGCMSVCHELPERS svcHelpers;
1170	SHFLROOT Root;
1171	const RTDIR hDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
1172	const int64_t ccAtimeNano = 100000;
1173	SHFLFSOBJINFO Info;
1174	SHFLHANDLE Handle;
1175	int rc;
1176
1177	RTTestSub(hTest, "Query and set directory atime");
1178	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1179	"/test/mapping", "testname");
1180	g_testRTDirOpen_hDir = hDir;
1181	rc = createFile(&svcTable, Root, "test/dir",
1182	SHFL_CF_DIRECTORY \| SHFL_CF_ACCESS_READ, &Handle, NULL);
1183	RTTEST_CHECK_RC_OK(hTest, rc);
1184	RT_ZERO(Info);
1185	RTTimeSpecSetNano(&g_testRTDirQueryInfo_ATime, ccAtimeNano);
1186	rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_FILE, sizeof(Info),
1187	&Info);
1188	RTTEST_CHECK_RC_OK(hTest, rc);
1189	RTTEST_CHECK_MSG(hTest, g_testRTDirQueryInfo_hDir == hDir, (hTest, "Dir=%p\n", g_testRTDirQueryInfo_hDir));
1190	RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&Info.AccessTime) == ccAtimeNano,
1191	(hTest, "ATime=%llu\n",
1192	LLUIFY(RTTimeSpecGetNano(&Info.AccessTime))));
1193	RT_ZERO(Info);
1194	RTTimeSpecSetNano(&Info.AccessTime, ccAtimeNano);
1195	rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET \| SHFL_INFO_FILE,
1196	sizeof(Info), &Info);
1197	RTTEST_CHECK_RC_OK(hTest, rc);
1198	RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&g_testRTDirSetTimes_ATime)
1199	== ccAtimeNano,
1200	(hTest, "ATime=%llu\n",
1201	LLUIFY(RTTimeSpecGetNano(&g_testRTDirSetTimes_ATime))));
1202	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1203	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1204	AssertReleaseRC(svcTable.pfnUnload(NULL));
1205	RTTestGuardedFree(hTest, svcTable.pvService);
1206	RTTEST_CHECK_MSG(hTest, g_testRTDirClose_hDir == hDir, (hTest, "hDir=%p\n", g_testRTDirClose_hDir));
1207	}
1208
1209	void testFSInfoQuerySetFileATime(RTTEST hTest)
1210	{
1211	VBOXHGCMSVCFNTABLE svcTable;
1212	VBOXHGCMSVCHELPERS svcHelpers;
1213	SHFLROOT Root;
1214	const RTFILE hFile = (RTFILE) 0x10000;
1215	const int64_t ccAtimeNano = 100000;
1216	SHFLFSOBJINFO Info;
1217	SHFLHANDLE Handle;
1218	int rc;
1219
1220	RTTestSub(hTest, "Query and set file atime");
1221	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1222	"/test/mapping", "testname");
1223	g_testRTFileOpen_hFile = hFile;
1224	rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
1225	&Handle, NULL);
1226	RTTEST_CHECK_RC_OK(hTest, rc);
1227	RT_ZERO(Info);
1228	RTTimeSpecSetNano(&g_testRTFileQueryInfo_ATime, ccAtimeNano);
1229	rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_FILE, sizeof(Info),
1230	&Info);
1231	RTTEST_CHECK_RC_OK(hTest, rc);
1232	RTTEST_CHECK_MSG(hTest, g_testRTFileQueryInfo_hFile == hFile, (hTest, "File=%u\n", g_testRTFileQueryInfo_hFile));
1233	RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&Info.AccessTime) == ccAtimeNano,
1234	(hTest, "ATime=%llu\n",
1235	LLUIFY(RTTimeSpecGetNano(&Info.AccessTime))));
1236	RT_ZERO(Info);
1237	RTTimeSpecSetNano(&Info.AccessTime, ccAtimeNano);
1238	rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET \| SHFL_INFO_FILE,
1239	sizeof(Info), &Info);
1240	RTTEST_CHECK_RC_OK(hTest, rc);
1241	RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&g_testRTFileSetTimes_ATime)
1242	== ccAtimeNano,
1243	(hTest, "ATime=%llu\n",
1244	LLUIFY(RTTimeSpecGetNano(&g_testRTFileSetTimes_ATime))));
1245	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1246	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1247	AssertReleaseRC(svcTable.pfnUnload(NULL));
1248	RTTestGuardedFree(hTest, svcTable.pvService);
1249	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile, (hTest, "File=%u\n", g_testRTFileClose_hFile));
1250	}
1251
1252	void testFSInfoQuerySetEndOfFile(RTTEST hTest)
1253	{
1254	VBOXHGCMSVCFNTABLE svcTable;
1255	VBOXHGCMSVCHELPERS svcHelpers;
1256	SHFLROOT Root;
1257	const RTFILE hFile = (RTFILE) 0x10000;
1258	const RTFOFF cbNew = 50000;
1259	SHFLFSOBJINFO Info;
1260	SHFLHANDLE Handle;
1261	int rc;
1262
1263	RTTestSub(hTest, "Set end of file position");
1264	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1265	"/test/mapping", "testname");
1266	g_testRTFileOpen_hFile = hFile;
1267	rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
1268	&Handle, NULL);
1269	RTTEST_CHECK_RC_OK(hTest, rc);
1270	RT_ZERO(Info);
1271	Info.cbObject = cbNew;
1272	rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET \| SHFL_INFO_SIZE,
1273	sizeof(Info), &Info);
1274	RTTEST_CHECK_RC_OK(hTest, rc);
1275	RTTEST_CHECK_MSG(hTest, g_testRTFileSetSize_hFile == hFile, (hTest, "File=%u\n", g_testRTFileSetSize_hFile));
1276	RTTEST_CHECK_MSG(hTest, g_testRTFileSetSize_cbSize == cbNew,
1277	(hTest, "Size=%llu\n", LLUIFY(g_testRTFileSetSize_cbSize)));
1278	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1279	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1280	AssertReleaseRC(svcTable.pfnUnload(NULL));
1281	RTTestGuardedFree(hTest, svcTable.pvService);
1282	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile, (hTest, "File=%u\n", g_testRTFileClose_hFile));
1283	}
1284
1285	void testLockFileSimple(RTTEST hTest)
1286	{
1287	VBOXHGCMSVCFNTABLE svcTable;
1288	VBOXHGCMSVCHELPERS svcHelpers;
1289	SHFLROOT Root;
1290	const RTFILE hFile = (RTFILE) 0x10000;
1291	const int64_t offLock = 50000;
1292	const uint64_t cbLock = 4000;
1293	SHFLHANDLE Handle;
1294	int rc;
1295
1296	RTTestSub(hTest, "Simple file lock and unlock");
1297	Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
1298	"/test/mapping", "testname");
1299	g_testRTFileOpen_hFile = hFile;
1300	rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
1301	&Handle, NULL);
1302	RTTEST_CHECK_RC_OK(hTest, rc);
1303	rc = lockFile(&svcTable, Root, Handle, offLock, cbLock, SHFL_LOCK_SHARED);
1304	RTTEST_CHECK_RC_OK(hTest, rc);
1305	#ifdef RT_OS_WINDOWS /* Locking is a no-op elsewhere. */
1306	RTTEST_CHECK_MSG(hTest, g_testRTFileLock_hFile == hFile, (hTest, "File=%u\n", g_testRTFileLock_hFile));
1307	RTTEST_CHECK_MSG(hTest, g_testRTFileLock_fLock == 0,
1308	(hTest, "fLock=%u\n", g_testRTFileLock_fLock));
1309	RTTEST_CHECK_MSG(hTest, g_testRTFileLock_offLock == offLock,
1310	(hTest, "Offs=%llu\n", (long long) g_testRTFileLock_offLock));
1311	RTTEST_CHECK_MSG(hTest, g_testRTFileLock_cbLock == cbLock,
1312	(hTest, "Size=%llu\n", LLUIFY(g_testRTFileLock_cbLock)));
1313	#endif
1314	rc = lockFile(&svcTable, Root, Handle, offLock, cbLock, SHFL_LOCK_CANCEL);
1315	RTTEST_CHECK_RC_OK(hTest, rc);
1316	#ifdef RT_OS_WINDOWS
1317	RTTEST_CHECK_MSG(hTest, g_testRTFileUnlock_hFile == hFile, (hTest, "File=%u\n", g_testRTFileUnlock_hFile));
1318	RTTEST_CHECK_MSG(hTest, g_testRTFileUnlock_offLock == offLock,
1319	(hTest, "Offs=%llu\n",
1320	(long long) g_testRTFileUnlock_offLock));
1321	RTTEST_CHECK_MSG(hTest, g_testRTFileUnlock_cbLock == cbLock,
1322	(hTest, "Size=%llu\n", LLUIFY(g_testRTFileUnlock_cbLock)));
1323	#endif
1324	unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
1325	AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
1326	AssertReleaseRC(svcTable.pfnUnload(NULL));
1327	RTTestGuardedFree(hTest, svcTable.pvService);
1328	RTTEST_CHECK_MSG(hTest, g_testRTFileClose_hFile == hFile, (hTest, "File=%u\n", g_testRTFileClose_hFile));
1329	}
1330
1331
1332	/*********************************************************************************************************************************
1333	* Main code *
1334	*********************************************************************************************************************************/
1335
1336	static void testAPI(RTTEST hTest)
1337	{
1338	testMappingsQuery(hTest);
1339	testMappingsQueryName(hTest);
1340	testMapFolder(hTest);
1341	testUnmapFolder(hTest);
1342	testCreate(hTest);
1343	testClose(hTest);
1344	testRead(hTest);
1345	testWrite(hTest);
1346	testLock(hTest);
1347	testFlush(hTest);
1348	testDirList(hTest);
1349	testReadLink(hTest);
1350	testFSInfo(hTest);
1351	testRemove(hTest);
1352	testRename(hTest);
1353	testSymlink(hTest);
1354	testMappingsAdd(hTest);
1355	testMappingsRemove(hTest);
1356	/* testSetStatusLed(hTest); */
1357	}
1358
1359	int main(int argc, char **argv)
1360	{
1361	RT_NOREF1(argc);
1362	RTEXITCODE rcExit = RTTestInitAndCreate(RTPathFilename(argv[0]), &g_hTest);
1363	if (rcExit != RTEXITCODE_SUCCESS)
1364	return rcExit;
1365	RTTestBanner(g_hTest);
1366	testAPI(g_hTest);
1367	return RTTestSummaryAndDestroy(g_hTest);
1368	}

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

source: vbox/trunk/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.cpp@ 96407

Download in other formats: