VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp@ 79563

最後變更 在這個檔案從79563是 79556,由 vboxsync 提交於 6 年 前

Shared Clipboard/testcase: Only RT_ZERO the client data state (is a POD type).
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 12.1 KB
行 
1/* $Id: tstClipboardServiceHost.cpp 79556 2019-07-05 12:25:55Z vboxsync $ */
2/** @file
3 * Shared Clipboard host service test case.
4 */
5
6/*
7 * Copyright (C) 2011-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.alldomusa.eu.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#include "../VBoxSharedClipboardSvc-internal.h"
19
20#include <VBox/HostServices/VBoxClipboardSvc.h>
21
22#include <iprt/assert.h>
23#include <iprt/string.h>
24#include <iprt/test.h>
25
26extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable);
27
28static VBOXCLIPBOARDCLIENTDATA g_Client;
29static VBOXHGCMSVCHELPERS g_Helpers = { NULL };
30
31/** Simple call handle structure for the guest call completion callback */
32struct VBOXHGCMCALLHANDLE_TYPEDEF
33{
34 /** Where to store the result code */
35 int32_t rc;
36};
37
38/** Call completion callback for guest calls. */
39static DECLCALLBACK(int) callComplete(VBOXHGCMCALLHANDLE callHandle, int32_t rc)
40{
41 callHandle->rc = rc;
42 return VINF_SUCCESS;
43}
44
45static int setupTable(VBOXHGCMSVCFNTABLE *pTable)
46{
47 pTable->cbSize = sizeof(*pTable);
48 pTable->u32Version = VBOX_HGCM_SVC_VERSION;
49 g_Helpers.pfnCallComplete = callComplete;
50 pTable->pHelpers = &g_Helpers;
51 return VBoxHGCMSvcLoad(pTable);
52}
53
54static void testSetMode(void)
55{
56 struct VBOXHGCMSVCPARM parms[2];
57 VBOXHGCMSVCFNTABLE table;
58 uint32_t u32Mode;
59 int rc;
60
61 RTTestISub("Testing HOST_FN_SET_MODE");
62 rc = setupTable(&table);
63 RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
64 /* Reset global variable which doesn't reset itself. */
65 HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_OFF);
66 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
67 1, parms);
68 RTTESTI_CHECK_RC_OK(rc);
69 u32Mode = TestClipSvcGetMode();
70 RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_OFF,
71 ("u32Mode=%u\n", (unsigned) u32Mode));
72 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
73 0, parms);
74 RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
75 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
76 2, parms);
77 RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
78 HGCMSvcSetU64(&parms[0], 99);
79 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
80 1, parms);
81 RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
82 HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST);
83 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
84 1, parms);
85 RTTESTI_CHECK_RC_OK(rc);
86 u32Mode = TestClipSvcGetMode();
87 RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST,
88 ("u32Mode=%u\n", (unsigned) u32Mode));
89 HGCMSvcSetU32(&parms[0], 99);
90 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
91 1, parms);
92 RTTESTI_CHECK_RC_OK(rc);
93 u32Mode = TestClipSvcGetMode();
94 RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_OFF,
95 ("u32Mode=%u\n", (unsigned) u32Mode));
96 table.pfnUnload(NULL);
97}
98
99static void testGetHostMsg(void)
100{
101 struct VBOXHGCMSVCPARM parms[2];
102 VBOXHGCMSVCFNTABLE table;
103 VBOXHGCMCALLHANDLE_TYPEDEF call;
104 int rc;
105
106 RTTestISub("Setting up VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG test");
107 rc = setupTable(&table);
108 RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
109 /* Unless we are bidirectional the host message requests will be dropped. */
110 HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL);
111 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
112 1, parms);
113 RTTESTI_CHECK_RC_OK(rc);
114
115 RTTestISub("Testing FN_GET_HOST_MSG, one format, waiting guest call.");
116 RT_ZERO(g_Client.State);
117 HGCMSvcSetU32(&parms[0], 0);
118 HGCMSvcSetU32(&parms[1], 0);
119 call.rc = VERR_TRY_AGAIN;
120 table.pfnConnect(NULL, 1 /* clientId */, &g_Client, 0, 0);
121 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
122 2, parms, 0);
123 RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN); /* This should get updated only when the guest call completes. */
124 vboxSvcClipboardReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
125 VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
126 RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
127 RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
128 RTTESTI_CHECK_RC_OK(call.rc);
129 call.rc = VERR_TRY_AGAIN;
130 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
131 2, parms, 0);
132 RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN); /* This call should not complete yet. */
133
134 RTTestISub("Testing FN_GET_HOST_MSG, one format, no waiting guest calls.");
135 RT_ZERO(g_Client.State);
136 vboxSvcClipboardReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
137 VBOX_SHARED_CLIPBOARD_FMT_HTML);
138 HGCMSvcSetU32(&parms[0], 0);
139 HGCMSvcSetU32(&parms[1], 0);
140 call.rc = VERR_TRY_AGAIN;
141 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
142 2, parms, 0);
143 RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
144 RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
145 RTTESTI_CHECK_RC_OK(call.rc);
146 call.rc = VERR_TRY_AGAIN;
147 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
148 2, parms, 0);
149 RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN); /* This call should not complete yet. */
150
151 RTTestISub("Testing FN_GET_HOST_MSG, two formats, waiting guest call.");
152 RT_ZERO(g_Client.State);
153 HGCMSvcSetU32(&parms[0], 0);
154 HGCMSvcSetU32(&parms[1], 0);
155 call.rc = VERR_TRY_AGAIN;
156 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
157 2, parms, 0);
158 RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN); /* This should get updated only when the guest call completes. */
159 vboxSvcClipboardReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
160 VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
161 RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
162 RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
163 RTTESTI_CHECK_RC_OK(call.rc);
164 call.rc = VERR_TRY_AGAIN;
165 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
166 2, parms, 0);
167 RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
168 RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
169 RTTESTI_CHECK_RC_OK(call.rc);
170 call.rc = VERR_TRY_AGAIN;
171 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
172 2, parms, 0);
173 RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN); /* This call should not complete yet. */
174
175 RTTestISub("Testing FN_GET_HOST_MSG, two formats, no waiting guest calls.");
176 RT_ZERO(g_Client.State);
177 vboxSvcClipboardReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
178 VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
179 HGCMSvcSetU32(&parms[0], 0);
180 HGCMSvcSetU32(&parms[1], 0);
181 call.rc = VERR_TRY_AGAIN;
182 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
183 2, parms, 0);
184 RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
185 RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
186 RTTESTI_CHECK_RC_OK(call.rc);
187 call.rc = VERR_TRY_AGAIN;
188 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
189 2, parms, 0);
190 RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
191 RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
192 RTTESTI_CHECK_RC_OK(call.rc);
193 call.rc = VERR_TRY_AGAIN;
194 table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
195 2, parms, 0);
196 RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN); /* This call should not complete yet. */
197 table.pfnDisconnect(NULL, 1 /* clientId */, &g_Client);
198 table.pfnUnload(NULL);
199}
200
201static void testSetHeadless(void)
202{
203 struct VBOXHGCMSVCPARM parms[2];
204 VBOXHGCMSVCFNTABLE table;
205 bool fHeadless;
206 int rc;
207
208 RTTestISub("Testing HOST_FN_SET_HEADLESS");
209 rc = setupTable(&table);
210 RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
211 /* Reset global variable which doesn't reset itself. */
212 HGCMSvcSetU32(&parms[0], false);
213 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
214 1, parms);
215 RTTESTI_CHECK_RC_OK(rc);
216 fHeadless = VBoxSvcClipboardGetHeadless();
217 RTTESTI_CHECK_MSG(fHeadless == false, ("fHeadless=%RTbool\n", fHeadless));
218 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
219 0, parms);
220 RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
221 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
222 2, parms);
223 RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
224 HGCMSvcSetU64(&parms[0], 99);
225 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
226 1, parms);
227 RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
228 HGCMSvcSetU32(&parms[0], true);
229 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
230 1, parms);
231 RTTESTI_CHECK_RC_OK(rc);
232 fHeadless = VBoxSvcClipboardGetHeadless();
233 RTTESTI_CHECK_MSG(fHeadless == true, ("fHeadless=%RTbool\n", fHeadless));
234 HGCMSvcSetU32(&parms[0], 99);
235 rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
236 1, parms);
237 RTTESTI_CHECK_RC_OK(rc);
238 fHeadless = VBoxSvcClipboardGetHeadless();
239 RTTESTI_CHECK_MSG(fHeadless == true, ("fHeadless=%RTbool\n", fHeadless));
240 table.pfnUnload(NULL);
241}
242
243static void testHostCall(void)
244{
245 testSetMode();
246 testSetHeadless();
247}
248
249
250int main(int argc, char *argv[])
251{
252 /*
253 * Init the runtime, test and say hello.
254 */
255 const char *pcszExecName;
256 NOREF(argc);
257 pcszExecName = strrchr(argv[0], '/');
258 pcszExecName = pcszExecName ? pcszExecName + 1 : argv[0];
259 RTTEST hTest;
260 RTEXITCODE rcExit = RTTestInitAndCreate(pcszExecName, &hTest);
261 if (rcExit != RTEXITCODE_SUCCESS)
262 return rcExit;
263 RTTestBanner(hTest);
264
265 /*
266 * Run the tests.
267 */
268 testHostCall();
269 testGetHostMsg();
270
271 /*
272 * Summary
273 */
274 return RTTestSummaryAndDestroy(hTest);
275}
276
277int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; }
278void VBoxClipboardSvcImplDestroy() { }
279int VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA)
280{ return VINF_SUCCESS; }
281int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA, bool)
282{ return VINF_SUCCESS; }
283int VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA, unsigned int)
284{ AssertFailed(); return VINF_SUCCESS; }
285int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA, unsigned int, void *, unsigned int, unsigned int *)
286{ AssertFailed(); return VERR_WRONG_ORDER; }
287int VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA, void *, unsigned int, unsigned int)
288{ AssertFailed(); return VINF_SUCCESS; }
289int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA)
290{ AssertFailed(); return VERR_WRONG_ORDER; }
291
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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