VirtualBox

source: vbox/trunk/src/VBox/GuestHost/SharedClipboard/testcases/tstClipboardGH-X11.cpp@ 82920

Last change on this file since 82920 was 82906, checked in by vboxsync, 5 years ago

Shared Clipboard/x11: Factored out common guest/host X11 testcases / smoktests into own files to clean up this #ifdef maze. tstClipboardGH-XXX also will emphasize what this actually is testing. bugref:9437
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 35.0 KB
Line 
1/* $Id: tstClipboardGH-X11.cpp 82906 2020-01-29 12:45:51Z vboxsync $ */
2/** @file
3 * Shared Clipboard guest/host X11 code test cases.
4 */
5
6/*
7 * Copyright (C) 2011-2020 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#include <VBox/GuestHost/SharedClipboard.h>
19#include <VBox/GuestHost/SharedClipboard-x11.h>
20#include <VBox/GuestHost/clipboard-helper.h>
21#include <VBox/HostServices/VBoxClipboardSvc.h>
22
23#include <iprt/assert.h>
24#include <iprt/string.h>
25#include <iprt/test.h>
26#include <iprt/utf16.h>
27
28#include <poll.h>
29#include <X11/Xatom.h>
30
31
32/*********************************************************************************************************************************
33* Externals *
34*********************************************************************************************************************************/
35extern SHCLX11FMTTABLE g_aFormats[];
36
37extern void clipUpdateX11Targets(PSHCLX11CTX pCtx, SHCLX11FMTIDX *pTargets, size_t cTargets);
38extern void clipReportEmptyX11CB(PSHCLX11CTX pCtx);
39extern void clipConvertDataFromX11CallbackWorker(void *pClient, void *pvSrc, unsigned cbSrc);
40extern SHCLX11FMTIDX clipGetTextFormatFromTargets(PSHCLX11CTX pCtx, SHCLX11FMTIDX *pTargets, size_t cTargets);
41extern SHCLX11FMT clipRealFormatForX11Format(SHCLX11FMTIDX uFmtIdx);
42extern Atom clipGetAtom(PSHCLX11CTX pCtx, const char *pcszName);
43
44
45/*********************************************************************************************************************************
46* Internal prototypes *
47*********************************************************************************************************************************/
48static SHCLX11FMTIDX tstClipFindX11FormatByAtomText(const char *pcszAtom);
49
50
51/*********************************************************************************************************************************
52* Prototypes, used for testcases by clipboard-x11.cpp *
53*********************************************************************************************************************************/
54void tstRequestTargets(SHCLX11CTX* pCtx);
55void tstClipRequestData(PSHCLX11CTX pCtx, SHCLX11FMTIDX target, void *closure);
56void tstClipQueueToEventThread(void (*proc)(void *, void *), void *client_data);
57
58
59/*********************************************************************************************************************************
60* Own callback implementations *
61*********************************************************************************************************************************/
62extern DECLCALLBACK(void) clipQueryX11FormatsCallback(PSHCLX11CTX pCtx);
63extern DECLCALLBACK(void) clipConvertX11TargetsCallback(Widget widget, XtPointer pClient,
64 Atom * /* selection */, Atom *atomType,
65 XtPointer pValue, long unsigned int *pcLen,
66 int *piFormat);
67
68
69/*********************************************************************************************************************************
70* Defines *
71*********************************************************************************************************************************/
72#define TESTCASE_WIDGET_ID (Widget)0xffff
73
74
75/* For the purpose of the test case, we just execute the procedure to be
76 * scheduled, as we are running single threaded. */
77void tstClipQueueToEventThread(void (*proc)(void *, void *), void *client_data)
78{
79 proc(client_data, NULL);
80}
81
82/* The data in the simulated VBox clipboard. */
83static int g_tst_rcDataVBox = VINF_SUCCESS;
84static void *g_tst_pvDataVBox = NULL;
85static uint32_t g_tst_cbDataVBox = 0;
86
87/* Set empty data in the simulated VBox clipboard. */
88static void tstClipEmptyVBox(PSHCLX11CTX pCtx, int retval)
89{
90 g_tst_rcDataVBox = retval;
91 RTMemFree(g_tst_pvDataVBox);
92 g_tst_pvDataVBox = NULL;
93 g_tst_cbDataVBox = 0;
94 ShClX11ReportFormatsToX11(pCtx, 0);
95}
96
97/* Set the data in the simulated VBox clipboard. */
98static int tstClipSetVBoxUtf16(PSHCLX11CTX pCtx, int retval,
99 const char *pcszData, size_t cb)
100{
101 PRTUTF16 pwszData = NULL;
102 size_t cwData = 0;
103 int rc = RTStrToUtf16Ex(pcszData, RTSTR_MAX, &pwszData, 0, &cwData);
104 if (RT_FAILURE(rc))
105 return rc;
106 AssertReturn(cb <= cwData * 2 + 2, VERR_BUFFER_OVERFLOW);
107 void *pv = RTMemDup(pwszData, cb);
108 RTUtf16Free(pwszData);
109 if (pv == NULL)
110 return VERR_NO_MEMORY;
111 if (g_tst_pvDataVBox)
112 RTMemFree(g_tst_pvDataVBox);
113 g_tst_rcDataVBox = retval;
114 g_tst_pvDataVBox = pv;
115 g_tst_cbDataVBox = cb;
116 ShClX11ReportFormatsToX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT);
117 return VINF_SUCCESS;
118}
119
120/* Return the data in the simulated VBox clipboard. */
121DECLCALLBACK(int) ShClX11RequestDataForX11Callback(PSHCLCONTEXT pCtx, uint32_t Format, void **ppv, uint32_t *pcb)
122{
123 RT_NOREF(pCtx, Format);
124 *pcb = g_tst_cbDataVBox;
125 if (g_tst_pvDataVBox != NULL)
126 {
127 void *pv = RTMemDup(g_tst_pvDataVBox, g_tst_cbDataVBox);
128 *ppv = pv;
129 return pv != NULL ? g_tst_rcDataVBox : VERR_NO_MEMORY;
130 }
131 *ppv = NULL;
132 return g_tst_rcDataVBox;
133}
134
135Display *XtDisplay(Widget w) { NOREF(w); return (Display *) 0xffff; }
136
137void XtAppSetExitFlag(XtAppContext app_context) { NOREF(app_context); }
138
139void XtDestroyWidget(Widget w) { NOREF(w); }
140
141XtAppContext XtCreateApplicationContext(void) { return (XtAppContext)0xffff; }
142
143void XtDestroyApplicationContext(XtAppContext app_context) { NOREF(app_context); }
144
145void XtToolkitInitialize(void) {}
146
147Boolean XtToolkitThreadInitialize(void) { return True; }
148
149Display *XtOpenDisplay(XtAppContext app_context,
150 _Xconst _XtString display_string,
151 _Xconst _XtString application_name,
152 _Xconst _XtString application_class,
153 XrmOptionDescRec *options, Cardinal num_options,
154 int *argc, char **argv)
155{
156 RT_NOREF8(app_context, display_string, application_name, application_class, options, num_options, argc, argv);
157 return (Display *)0xffff;
158}
159
160Widget XtVaAppCreateShell(_Xconst _XtString application_name, _Xconst _XtString application_class,
161 WidgetClass widget_class, Display *display, ...)
162{
163 RT_NOREF(application_name, application_class, widget_class, display);
164 return TESTCASE_WIDGET_ID;
165}
166
167void XtSetMappedWhenManaged(Widget widget, _XtBoolean mapped_when_managed) { RT_NOREF(widget, mapped_when_managed); }
168
169void XtRealizeWidget(Widget widget) { NOREF(widget); }
170
171XtInputId XtAppAddInput(XtAppContext app_context, int source, XtPointer condition, XtInputCallbackProc proc, XtPointer closure)
172{
173 RT_NOREF(app_context, source, condition, proc, closure);
174 return 0xffff;
175}
176
177/* Atoms we need other than the formats we support. */
178static const char *g_tst_apszSupAtoms[] =
179{
180 "PRIMARY", "CLIPBOARD", "TARGETS", "MULTIPLE", "TIMESTAMP"
181};
182
183/* This just looks for the atom names in a couple of tables and returns an
184 * index with an offset added. */
185Atom XInternAtom(Display *, const char *pcsz, int)
186{
187 Atom atom = 0;
188 unsigned i = 0;
189 while (g_aFormats[i].pcszAtom)
190 {
191 if (!strcmp(pcsz, g_aFormats[i].pcszAtom))
192 atom = (Atom) (i + 0x1000);
193 ++i;
194 }
195 for (i = 0; i < RT_ELEMENTS(g_tst_apszSupAtoms); ++i)
196 if (!strcmp(pcsz, g_tst_apszSupAtoms[i]))
197 atom = (Atom) (i + 0x2000);
198 Assert(atom); /* Have we missed any atoms? */
199 return atom;
200}
201
202/* Take a request for the targets we are currently offering. */
203static SHCLX11FMTIDX g_tst_aSelTargetsIdx[10] = { 0 };
204static size_t g_tst_cTargets = 0;
205
206void tstRequestTargets(SHCLX11CTX* pCtx)
207{
208 clipUpdateX11Targets(pCtx, g_tst_aSelTargetsIdx, g_tst_cTargets);
209}
210
211/* The current values of the X selection, which will be returned to the
212 * XtGetSelectionValue callback. */
213static Atom g_tst_atmSelType = 0;
214static const void *g_tst_pSelData = NULL;
215static unsigned long g_tst_cSelData = 0;
216static int g_tst_selFormat = 0;
217
218void tstClipRequestData(PSHCLX11CTX pCtx, SHCLX11FMTIDX target, void *closure)
219{
220 RT_NOREF(pCtx);
221 unsigned long count = 0;
222 int format = 0;
223 if (target != g_tst_aSelTargetsIdx[0])
224 {
225 clipConvertDataFromX11CallbackWorker(closure, NULL, 0); /* Could not convert to target. */
226 return;
227 }
228 void *pValue = NULL;
229 pValue = g_tst_pSelData ? RTMemDup(g_tst_pSelData, g_tst_cSelData) : NULL;
230 count = g_tst_pSelData ? g_tst_cSelData : 0;
231 format = g_tst_selFormat;
232 if (!pValue)
233 {
234 count = 0;
235 format = 0;
236 }
237 clipConvertDataFromX11CallbackWorker(closure, pValue, count * format / 8);
238 if (pValue)
239 RTMemFree(pValue);
240}
241
242/* The formats currently on offer from X11 via the shared clipboard. */
243static uint32_t g_tst_uX11Formats = 0;
244
245DECLCALLBACK(void) ShClX11ReportFormatsCallback(PSHCLCONTEXT pCtx, SHCLFORMATS Formats)
246{
247 RT_NOREF(pCtx);
248 g_tst_uX11Formats = Formats;
249}
250
251static uint32_t tstClipQueryFormats(void)
252{
253 return g_tst_uX11Formats;
254}
255
256static void tstClipInvalidateFormats(void)
257{
258 g_tst_uX11Formats = ~0;
259}
260
261/* Does our clipboard code currently own the selection? */
262static bool g_tst_fOwnsSel = false;
263/* The procedure that is called when we should convert the selection to a
264 * given format. */
265static XtConvertSelectionProc g_tst_pfnSelConvert = NULL;
266/* The procedure which is called when we lose the selection. */
267static XtLoseSelectionProc g_tst_pfnSelLose = NULL;
268/* The procedure which is called when the selection transfer has completed. */
269static XtSelectionDoneProc g_tst_pfnSelDone = NULL;
270
271Boolean XtOwnSelection(Widget widget, Atom selection, Time time,
272 XtConvertSelectionProc convert,
273 XtLoseSelectionProc lose,
274 XtSelectionDoneProc done)
275{
276 RT_NOREF(widget, time);
277 if (selection != XInternAtom(NULL, "CLIPBOARD", 0))
278 return True; /* We don't really care about this. */
279 g_tst_fOwnsSel = true; /* Always succeed. */
280 g_tst_pfnSelConvert = convert;
281 g_tst_pfnSelLose = lose;
282 g_tst_pfnSelDone = done;
283 return True;
284}
285
286void XtDisownSelection(Widget widget, Atom selection, Time time)
287{
288 RT_NOREF(widget, time, selection);
289 g_tst_fOwnsSel = false;
290 g_tst_pfnSelConvert = NULL;
291 g_tst_pfnSelLose = NULL;
292 g_tst_pfnSelDone = NULL;
293}
294
295/* Request the shared clipboard to convert its data to a given format. */
296static bool tstClipConvertSelection(const char *pcszTarget, Atom *type,
297 XtPointer *value, unsigned long *length,
298 int *format)
299{
300 Atom target = XInternAtom(NULL, pcszTarget, 0);
301 if (target == 0)
302 return false;
303 /* Initialise all return values in case we make a quick exit. */
304 *type = XA_STRING;
305 *value = NULL;
306 *length = 0;
307 *format = 0;
308 if (!g_tst_fOwnsSel)
309 return false;
310 if (!g_tst_pfnSelConvert)
311 return false;
312 Atom clipAtom = XInternAtom(NULL, "CLIPBOARD", 0);
313 if (!g_tst_pfnSelConvert(TESTCASE_WIDGET_ID, &clipAtom, &target, type,
314 value, length, format))
315 return false;
316 if (g_tst_pfnSelDone)
317 g_tst_pfnSelDone(TESTCASE_WIDGET_ID, &clipAtom, &target);
318 return true;
319}
320
321/* Set the current X selection data */
322static void tstClipSetSelectionValues(const char *pcszTarget, Atom type,
323 const void *data,
324 unsigned long count, int format)
325{
326 Atom clipAtom = XInternAtom(NULL, "CLIPBOARD", 0);
327 g_tst_aSelTargetsIdx[0] = tstClipFindX11FormatByAtomText(pcszTarget);
328 g_tst_cTargets = 1;
329 g_tst_atmSelType = type;
330 g_tst_pSelData = data;
331 g_tst_cSelData = count;
332 g_tst_selFormat = format;
333 if (g_tst_pfnSelLose)
334 g_tst_pfnSelLose(TESTCASE_WIDGET_ID, &clipAtom);
335 g_tst_fOwnsSel = false;
336}
337
338static void tstClipSendTargetUpdate(PSHCLX11CTX pCtx)
339{
340 clipQueryX11FormatsCallback(pCtx);
341}
342
343/* Configure if and how the X11 TARGETS clipboard target will fail. */
344static void tstClipSetTargetsFailure(void)
345{
346 g_tst_cTargets = 0;
347}
348
349char *XtMalloc(Cardinal size)
350{
351 return (char *) RTMemAlloc(size);
352}
353
354void XtFree(char *ptr)
355{
356 RTMemFree((void *)ptr);
357}
358
359char *XGetAtomName(Display *display, Atom atom)
360{
361 RT_NOREF(display);
362 const char *pcszName = NULL;
363 if (atom < 0x1000)
364 return NULL;
365 if (0x1000 <= atom && atom < 0x2000)
366 {
367 unsigned index = atom - 0x1000;
368 pcszName = g_aFormats[index].pcszAtom;
369 }
370 else
371 {
372 unsigned index = atom - 0x2000;
373 AssertReturn(index < RT_ELEMENTS(g_tst_apszSupAtoms), NULL);
374 pcszName = g_tst_apszSupAtoms[index];
375 }
376 return (char *)RTMemDup(pcszName, sizeof(pcszName) + 1);
377}
378
379int XFree(void *data)
380{
381 RTMemFree(data);
382 return 0;
383}
384
385void XFreeStringList(char **list)
386{
387 if (list)
388 RTMemFree(*list);
389 RTMemFree(list);
390}
391
392#define TESTCASE_MAX_BUF_SIZE 256
393
394static int g_tst_rcCompleted = VINF_SUCCESS;
395static int g_tst_cbCompleted = 0;
396static CLIPREADCBREQ *g_tst_pCompletedReq = NULL;
397static char g_tst_abCompletedBuf[TESTCASE_MAX_BUF_SIZE];
398
399void ShClX11RequestFromX11CompleteCallback(PSHCLCONTEXT pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
400{
401 RT_NOREF(pCtx);
402 if (cb <= TESTCASE_MAX_BUF_SIZE)
403 {
404 g_tst_rcCompleted = rc;
405 if (cb != 0)
406 memcpy(g_tst_abCompletedBuf, pv, cb);
407 }
408 else
409 g_tst_rcCompleted = VERR_BUFFER_OVERFLOW;
410 g_tst_cbCompleted = cb;
411 g_tst_pCompletedReq = pReq;
412}
413
414/**
415 * Looks up the X11 format matching a given X11 atom text.
416 *
417 * @returns the format on success, NIL_CLIPX11FORMAT on failure
418 * @param pcszAtom Atom text to look up format for.
419 */
420static SHCLX11FMTIDX tstClipFindX11FormatByAtomText(const char *pcszAtom)
421{
422 unsigned i = 0;
423 while (g_aFormats[i].pcszAtom)
424 {
425 if (!strcmp(g_aFormats[i].pcszAtom, pcszAtom))
426 return i;
427 ++i;
428 }
429 return NIL_CLIPX11FORMAT;
430}
431
432static bool tstClipTextFormatConversion(PSHCLX11CTX pCtx)
433{
434 bool fSuccess = true;
435 SHCLX11FMTIDX targets[2];
436 SHCLX11FMTIDX x11Format;
437 targets[0] = tstClipFindX11FormatByAtomText("text/plain");
438 targets[1] = tstClipFindX11FormatByAtomText("image/bmp");
439 x11Format = clipGetTextFormatFromTargets(pCtx, targets, 2);
440 if (clipRealFormatForX11Format(x11Format) != SHCLX11FMT_TEXT)
441 fSuccess = false;
442 targets[0] = tstClipFindX11FormatByAtomText("UTF8_STRING");
443 targets[1] = tstClipFindX11FormatByAtomText("text/plain");
444 x11Format = clipGetTextFormatFromTargets(pCtx, targets, 2);
445 if (clipRealFormatForX11Format(x11Format) != SHCLX11FMT_UTF8)
446 fSuccess = false;
447 return fSuccess;
448}
449
450static void tstClipGetCompletedRequest(int *prc, char ** ppc, uint32_t *pcb, CLIPREADCBREQ **ppReq)
451{
452 *prc = g_tst_rcCompleted;
453 *ppc = g_tst_abCompletedBuf;
454 *pcb = g_tst_cbCompleted;
455 *ppReq = g_tst_pCompletedReq;
456}
457#ifdef RT_OS_SOLARIS_10
458char XtStrings [] = "";
459_WidgetClassRec* applicationShellWidgetClass;
460char XtShellStrings [] = "";
461int XmbTextPropertyToTextList(
462 Display* /* display */,
463 XTextProperty* /* text_prop */,
464 char*** /* list_return */,
465 int* /* count_return */
466)
467{
468 return 0;
469}
470#else
471const char XtStrings [] = "";
472_WidgetClassRec* applicationShellWidgetClass;
473const char XtShellStrings [] = "";
474#endif
475
476static void tstStringFromX11(RTTEST hTest, PSHCLX11CTX pCtx,
477 const char *pcszExp, int rcExp)
478{
479 bool retval = true;
480 tstClipSendTargetUpdate(pCtx);
481 if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
482 {
483 RTTestFailed(hTest, "Wrong targets reported: %02X\n", tstClipQueryFormats());
484 }
485 else
486 {
487 char *pc;
488 CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL;
489 ShClX11ReadDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT, pReq);
490 int rc = VINF_SUCCESS;
491 uint32_t cbActual = 0;
492 tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
493 if (rc != rcExp)
494 RTTestFailed(hTest, "Wrong return code, expected %Rrc, got %Rrc\n",
495 rcExp, rc);
496 else if (pReqRet != pReq)
497 RTTestFailed(hTest, "Wrong returned request data, expected %p, got %p\n",
498 pReq, pReqRet);
499 else if (RT_FAILURE(rcExp))
500 retval = true;
501 else
502 {
503 RTUTF16 wcExp[TESTCASE_MAX_BUF_SIZE / 2];
504 RTUTF16 *pwcExp = wcExp;
505 size_t cwc = 0;
506 rc = RTStrToUtf16Ex(pcszExp, RTSTR_MAX, &pwcExp,
507 RT_ELEMENTS(wcExp), &cwc);
508 size_t cbExp = cwc * 2 + 2;
509 AssertRC(rc);
510 if (RT_SUCCESS(rc))
511 {
512 if (cbActual != cbExp)
513 {
514 RTTestFailed(hTest, "Returned string is the wrong size, string \"%.*ls\", size %u, expected \"%s\", size %u\n",
515 RT_MIN(TESTCASE_MAX_BUF_SIZE, cbActual), pc, cbActual,
516 pcszExp, cbExp);
517 }
518 else
519 {
520 if (memcmp(pc, wcExp, cbExp) == 0)
521 retval = true;
522 else
523 RTTestFailed(hTest, "Returned string \"%.*ls\" does not match expected string \"%s\"\n",
524 TESTCASE_MAX_BUF_SIZE, pc, pcszExp);
525 }
526 }
527 }
528 }
529 if (!retval)
530 RTTestFailureDetails(hTest, "Expected: string \"%s\", rc %Rrc\n",
531 pcszExp, rcExp);
532}
533
534static void tstLatin1FromX11(RTTEST hTest, PSHCLX11CTX pCtx,
535 const char *pcszExp, int rcExp)
536{
537 bool retval = false;
538 tstClipSendTargetUpdate(pCtx);
539 if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
540 RTTestFailed(hTest, "Wrong targets reported: %02X\n",
541 tstClipQueryFormats());
542 else
543 {
544 char *pc;
545 CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL;
546 ShClX11ReadDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT, pReq);
547 int rc = VINF_SUCCESS;
548 uint32_t cbActual = 0;
549 tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
550 if (rc != rcExp)
551 RTTestFailed(hTest, "Wrong return code, expected %Rrc, got %Rrc\n",
552 rcExp, rc);
553 else if (pReqRet != pReq)
554 RTTestFailed(hTest, "Wrong returned request data, expected %p, got %p\n",
555 pReq, pReqRet);
556 else if (RT_FAILURE(rcExp))
557 retval = true;
558 else
559 {
560 RTUTF16 wcExp[TESTCASE_MAX_BUF_SIZE / 2];
561 //RTUTF16 *pwcExp = wcExp; - unused
562 size_t cwc;
563 for (cwc = 0; cwc == 0 || pcszExp[cwc - 1] != '\0'; ++cwc)
564 wcExp[cwc] = pcszExp[cwc];
565 size_t cbExp = cwc * 2;
566 if (cbActual != cbExp)
567 {
568 RTTestFailed(hTest, "Returned string is the wrong size, string \"%.*ls\", size %u, expected \"%s\", size %u\n",
569 RT_MIN(TESTCASE_MAX_BUF_SIZE, cbActual), pc, cbActual,
570 pcszExp, cbExp);
571 }
572 else
573 {
574 if (memcmp(pc, wcExp, cbExp) == 0)
575 retval = true;
576 else
577 RTTestFailed(hTest, "Returned string \"%.*ls\" does not match expected string \"%s\"\n",
578 TESTCASE_MAX_BUF_SIZE, pc, pcszExp);
579 }
580 }
581 }
582 if (!retval)
583 RTTestFailureDetails(hTest, "Expected: string \"%s\", rc %Rrc\n",
584 pcszExp, rcExp);
585}
586
587static void tstStringFromVBox(RTTEST hTest, PSHCLX11CTX pCtx, const char *pcszTarget, Atom typeExp, const char *valueExp)
588{
589 RT_NOREF(pCtx);
590 bool retval = false;
591 Atom type;
592 XtPointer value = NULL;
593 unsigned long length;
594 int format;
595 size_t lenExp = strlen(valueExp);
596 if (tstClipConvertSelection(pcszTarget, &type, &value, &length, &format))
597 {
598 if ( type != typeExp
599 || length != lenExp
600 || format != 8
601 || memcmp((const void *) value, (const void *)valueExp,
602 lenExp))
603 {
604 RTTestFailed(hTest, "Bad data: type %d, (expected %d), length %u, (%u), format %d (%d), value \"%.*s\" (\"%.*s\")\n",
605 type, typeExp, length, lenExp, format, 8,
606 RT_MIN(length, 20), value, RT_MIN(lenExp, 20), valueExp);
607 }
608 else
609 retval = true;
610 }
611 else
612 RTTestFailed(hTest, "Conversion failed\n");
613 XtFree((char *)value);
614 if (!retval)
615 RTTestFailureDetails(hTest, "Conversion to %s, expected \"%s\"\n",
616 pcszTarget, valueExp);
617}
618
619static void tstNoX11(PSHCLX11CTX pCtx, const char *pcszTestCtx)
620{
621 CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq;
622 int rc = ShClX11ReadDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT, pReq);
623 RTTESTI_CHECK_MSG(rc == VERR_NO_DATA, ("context: %s\n", pcszTestCtx));
624}
625
626static void tstStringFromVBoxFailed(RTTEST hTest, PSHCLX11CTX pCtx, const char *pcszTarget)
627{
628 RT_NOREF(pCtx);
629 Atom type;
630 XtPointer value = NULL;
631 unsigned long length;
632 int format;
633 RTTEST_CHECK_MSG(hTest, !tstClipConvertSelection(pcszTarget, &type, &value,
634 &length, &format),
635 (hTest, "Conversion to target %s, should have failed but didn't, returned type %d, length %u, format %d, value \"%.*s\"\n",
636 pcszTarget, type, length, format, RT_MIN(length, 20),
637 value));
638 XtFree((char *)value);
639}
640
641static void tstNoSelectionOwnership(PSHCLX11CTX pCtx, const char *pcszTestCtx)
642{
643 RT_NOREF(pCtx);
644 RTTESTI_CHECK_MSG(!g_tst_fOwnsSel, ("context: %s\n", pcszTestCtx));
645}
646
647static void tstBadFormatRequestFromHost(RTTEST hTest, PSHCLX11CTX pCtx)
648{
649 tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
650 sizeof("hello world"), 8);
651 tstClipSendTargetUpdate(pCtx);
652 if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT)
653 RTTestFailed(hTest, "Wrong targets reported: %02X\n",
654 tstClipQueryFormats());
655 else
656 {
657 char *pc;
658 CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL;
659 ShClX11ReadDataFromX11(pCtx, 0xF000 /* vboxFormat */, pReq); /* Bad format. */
660 int rc = VINF_SUCCESS;
661 uint32_t cbActual = 0;
662 tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
663 if (rc != VERR_NOT_IMPLEMENTED)
664 RTTestFailed(hTest, "Wrong return code, expected VERR_NOT_IMPLEMENTED, got %Rrc\n",
665 rc);
666 tstClipSetSelectionValues("", XA_STRING, "", sizeof(""), 8);
667 tstClipSendTargetUpdate(pCtx);
668 if (tstClipQueryFormats() == VBOX_SHCL_FMT_UNICODETEXT)
669 RTTestFailed(hTest, "Failed to report targets after bad host request.\n");
670 }
671}
672
673int main()
674{
675 /*
676 * Init the runtime, test and say hello.
677 */
678 RTTEST hTest;
679 int rc = RTTestInitAndCreate("tstClipboardGH-X11", &hTest);
680 if (rc)
681 return rc;
682 RTTestBanner(hTest);
683
684 /*
685 * Run the tests.
686 */
687 SHCLX11CTX X11Ctx;
688 rc = ShClX11Init(&X11Ctx, NULL, false);
689 AssertRCReturn(rc, 1);
690 char *pc;
691 uint32_t cbActual;
692 CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL;
693 rc = ShClX11ThreadStart(&X11Ctx, false /* fGrab */);
694 AssertRCReturn(rc, 1);
695
696 /* UTF-8 from X11 */
697 RTTestSub(hTest, "reading UTF-8 from X11");
698 /* Simple test */
699 tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
700 sizeof("hello world"), 8);
701 tstStringFromX11(hTest, &X11Ctx, "hello world", VINF_SUCCESS);
702 /* With an embedded carriage return */
703 tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
704 "hello\nworld", sizeof("hello\nworld"), 8);
705 tstStringFromX11(hTest, &X11Ctx, "hello\r\nworld", VINF_SUCCESS);
706 /* With an embedded CRLF */
707 tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
708 "hello\r\nworld", sizeof("hello\r\nworld"), 8);
709 tstStringFromX11(hTest, &X11Ctx, "hello\r\r\nworld", VINF_SUCCESS);
710 /* With an embedded LFCR */
711 tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING,
712 "hello\n\rworld", sizeof("hello\n\rworld"), 8);
713 tstStringFromX11(hTest, &X11Ctx, "hello\r\n\rworld", VINF_SUCCESS);
714 /* An empty string */
715 tstClipSetSelectionValues("text/plain;charset=utf-8", XA_STRING, "",
716 sizeof(""), 8);
717 tstStringFromX11(hTest, &X11Ctx, "", VINF_SUCCESS);
718 /* With an embedded UTF-8 character. */
719 tstClipSetSelectionValues("STRING", XA_STRING,
720 "100\xE2\x82\xAC" /* 100 Euro */,
721 sizeof("100\xE2\x82\xAC"), 8);
722 tstStringFromX11(hTest, &X11Ctx, "100\xE2\x82\xAC", VINF_SUCCESS);
723 /* A non-zero-terminated string */
724 tstClipSetSelectionValues("TEXT", XA_STRING,
725 "hello world", sizeof("hello world") - 1, 8);
726 tstStringFromX11(hTest, &X11Ctx, "hello world", VINF_SUCCESS);
727
728 /* Latin1 from X11 */
729 RTTestSub(hTest, "reading Latin1 from X11");
730 /* Simple test */
731 tstClipSetSelectionValues("STRING", XA_STRING, "Georges Dupr\xEA",
732 sizeof("Georges Dupr\xEA"), 8);
733 tstLatin1FromX11(hTest, &X11Ctx, "Georges Dupr\xEA", VINF_SUCCESS);
734 /* With an embedded carriage return */
735 tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\nDupr\xEA",
736 sizeof("Georges\nDupr\xEA"), 8);
737 tstLatin1FromX11(hTest, &X11Ctx, "Georges\r\nDupr\xEA", VINF_SUCCESS);
738 /* With an embedded CRLF */
739 tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\r\nDupr\xEA",
740 sizeof("Georges\r\nDupr\xEA"), 8);
741 tstLatin1FromX11(hTest, &X11Ctx, "Georges\r\r\nDupr\xEA", VINF_SUCCESS);
742 /* With an embedded LFCR */
743 tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\n\rDupr\xEA",
744 sizeof("Georges\n\rDupr\xEA"), 8);
745 tstLatin1FromX11(hTest, &X11Ctx, "Georges\r\n\rDupr\xEA", VINF_SUCCESS);
746 /* A non-zero-terminated string */
747 tstClipSetSelectionValues("text/plain", XA_STRING,
748 "Georges Dupr\xEA!",
749 sizeof("Georges Dupr\xEA!") - 1, 8);
750 tstLatin1FromX11(hTest, &X11Ctx, "Georges Dupr\xEA!", VINF_SUCCESS);
751
752 /*
753 * Unknown X11 format
754 */
755 RTTestSub(hTest, "handling of an unknown X11 format");
756 tstClipInvalidateFormats();
757 tstClipSetSelectionValues("CLIPBOARD", XA_STRING, "Test",
758 sizeof("Test"), 8);
759 tstClipSendTargetUpdate(&X11Ctx);
760 RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0,
761 (hTest, "Failed to send a format update notification\n"));
762
763 /*
764 * Timeout from X11
765 */
766 RTTestSub(hTest, "X11 timeout");
767 tstClipSetSelectionValues("UTF8_STRING", XT_CONVERT_FAIL, NULL,0, 8);
768 tstStringFromX11(hTest, &X11Ctx, "", VERR_NO_DATA);
769
770 /*
771 * No data in X11 clipboard
772 */
773 RTTestSub(hTest, "a data request from an empty X11 clipboard");
774 tstClipSetSelectionValues("UTF8_STRING", XA_STRING, NULL,
775 0, 8);
776 ShClX11ReadDataFromX11(&X11Ctx, VBOX_SHCL_FMT_UNICODETEXT, pReq);
777 tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
778 RTTEST_CHECK_MSG(hTest, rc == VERR_NO_DATA,
779 (hTest, "Returned %Rrc instead of VERR_NO_DATA\n",
780 rc));
781 RTTEST_CHECK_MSG(hTest, pReqRet == pReq,
782 (hTest, "Wrong returned request data, expected %p, got %p\n",
783 pReq, pReqRet));
784
785 /*
786 * Ensure that VBox is notified when we return the CB to X11
787 */
788 RTTestSub(hTest, "notification of switch to X11 clipboard");
789 tstClipInvalidateFormats();
790 clipReportEmptyX11CB(&X11Ctx);
791 RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0,
792 (hTest, "Failed to send a format update (release) notification\n"));
793
794 /*
795 * Request for an invalid VBox format from X11
796 */
797 RTTestSub(hTest, "a request for an invalid VBox format from X11");
798 /* Testing for 0xffff will go into handling VBOX_SHCL_FMT_UNICODETEXT, where we don't have
799 * have any data at the moment so far, so this will return VERR_NO_DATA. */
800 ShClX11ReadDataFromX11(&X11Ctx, 0xffff /* vboxFormat */, pReq);
801 tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet);
802 RTTEST_CHECK_MSG(hTest, rc == VERR_NO_DATA,
803 (hTest, "Returned %Rrc instead of VERR_NO_DATA\n",
804 rc));
805 RTTEST_CHECK_MSG(hTest, pReqRet == pReq,
806 (hTest, "Wrong returned request data, expected %p, got %p\n",
807 pReq, pReqRet));
808
809 /*
810 * Targets failure from X11
811 */
812 RTTestSub(hTest, "X11 targets conversion failure");
813 tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
814 sizeof("hello world"), 8);
815 tstClipSetTargetsFailure();
816 Atom atom = XA_STRING;
817 long unsigned int cLen = 0;
818 int format = 8;
819 clipConvertX11TargetsCallback(NULL, (XtPointer) &X11Ctx, NULL, &atom, NULL, &cLen,
820 &format);
821 RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0,
822 (hTest, "Wrong targets reported: %02X\n",
823 tstClipQueryFormats()));
824
825 /*
826 * X11 text format conversion
827 */
828 RTTestSub(hTest, "handling of X11 selection targets");
829 RTTEST_CHECK_MSG(hTest, tstClipTextFormatConversion(&X11Ctx),
830 (hTest, "failed to select the right X11 text formats\n"));
831
832 /*
833 * UTF-8 from VBox
834 */
835 RTTestSub(hTest, "reading UTF-8 from VBox");
836 /* Simple test */
837 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello world",
838 sizeof("hello world") * 2);
839 tstStringFromVBox(hTest, &X11Ctx, "UTF8_STRING",
840 clipGetAtom(&X11Ctx, "UTF8_STRING"), "hello world");
841 /* With an embedded carriage return */
842 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello\r\nworld",
843 sizeof("hello\r\nworld") * 2);
844 tstStringFromVBox(hTest, &X11Ctx, "text/plain;charset=UTF-8",
845 clipGetAtom(&X11Ctx, "text/plain;charset=UTF-8"),
846 "hello\nworld");
847 /* With an embedded CRCRLF */
848 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello\r\r\nworld",
849 sizeof("hello\r\r\nworld") * 2);
850 tstStringFromVBox(hTest, &X11Ctx, "text/plain;charset=UTF-8",
851 clipGetAtom(&X11Ctx, "text/plain;charset=UTF-8"),
852 "hello\r\nworld");
853 /* With an embedded CRLFCR */
854 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello\r\n\rworld",
855 sizeof("hello\r\n\rworld") * 2);
856 tstStringFromVBox(hTest, &X11Ctx, "text/plain;charset=UTF-8",
857 clipGetAtom(&X11Ctx, "text/plain;charset=UTF-8"),
858 "hello\n\rworld");
859 /* An empty string */
860 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "", 2);
861 tstStringFromVBox(hTest, &X11Ctx, "text/plain;charset=utf-8",
862 clipGetAtom(&X11Ctx, "text/plain;charset=utf-8"), "");
863 /* With an embedded UTF-8 character. */
864 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "100\xE2\x82\xAC" /* 100 Euro */,
865 10);
866 tstStringFromVBox(hTest, &X11Ctx, "STRING",
867 clipGetAtom(&X11Ctx, "STRING"), "100\xE2\x82\xAC");
868 /* A non-zero-terminated string */
869 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello world",
870 sizeof("hello world") * 2 - 2);
871 tstStringFromVBox(hTest, &X11Ctx, "TEXT", clipGetAtom(&X11Ctx, "TEXT"),
872 "hello world");
873
874 /*
875 * Timeout from VBox
876 */
877 RTTestSub(hTest, "reading from VBox with timeout");
878 tstClipEmptyVBox(&X11Ctx, VERR_TIMEOUT);
879 tstStringFromVBoxFailed(hTest, &X11Ctx, "UTF8_STRING");
880
881 /*
882 * No data in VBox clipboard
883 */
884 RTTestSub(hTest, "an empty VBox clipboard");
885 tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
886 tstClipEmptyVBox(&X11Ctx, VINF_SUCCESS);
887 RTTEST_CHECK_MSG(hTest, g_tst_fOwnsSel,
888 (hTest, "VBox grabbed the clipboard with no data and we ignored it\n"));
889 tstStringFromVBoxFailed(hTest, &X11Ctx, "UTF8_STRING");
890
891 /*
892 * An unknown VBox format
893 */
894 RTTestSub(hTest, "reading an unknown VBox format");
895 tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
896 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "", 2);
897 ShClX11ReportFormatsToX11(&X11Ctx, 0xa0000);
898 RTTEST_CHECK_MSG(hTest, g_tst_fOwnsSel,
899 (hTest, "VBox grabbed the clipboard with unknown data and we ignored it\n"));
900 tstStringFromVBoxFailed(hTest, &X11Ctx, "UTF8_STRING");
901
902 /*
903 * VBox requests a bad format
904 */
905 RTTestSub(hTest, "recovery from a bad format request");
906 tstBadFormatRequestFromHost(hTest, &X11Ctx);
907
908 rc = ShClX11ThreadStop(&X11Ctx);
909 AssertRCReturn(rc, 1);
910 ShClX11Destroy(&X11Ctx);
911
912 /*
913 * Headless clipboard tests
914 */
915 rc = ShClX11Init(&X11Ctx, NULL, true);
916 AssertRCReturn(rc, 1);
917 rc = ShClX11ThreadStart(&X11Ctx, false /* fGrab */);
918 AssertRCReturn(rc, 1);
919
920 /* Read from X11 */
921 RTTestSub(hTest, "reading from X11, headless clipboard");
922 /* Simple test */
923 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "",
924 sizeof("") * 2);
925 tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world",
926 sizeof("hello world"), 8);
927 tstNoX11(&X11Ctx, "reading from X11, headless clipboard");
928
929 /* Read from VBox */
930 RTTestSub(hTest, "reading from VBox, headless clipboard");
931 /* Simple test */
932 tstClipEmptyVBox(&X11Ctx, VERR_WRONG_ORDER);
933 tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8);
934 tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello world",
935 sizeof("hello world") * 2);
936 tstNoSelectionOwnership(&X11Ctx, "reading from VBox, headless clipboard");
937
938 rc = ShClX11ThreadStop(&X11Ctx);
939 AssertRCReturn(rc, 1);
940
941 ShClX11Destroy(&X11Ctx);
942
943 return RTTestSummaryAndDestroy(hTest);
944}
945
Note: See TracBrowser for help on using the repository browser.

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