Atlas - testautomation

Atlas - testautomation_clipboard.c
Home / ext / SDL / test
Lines: 1 | Size: 22072 bytes
[Download] [Show on GitHub] [Search similar files] [Raw] [Raw (proxy)] 
[FILE BEGIN]
1/**
2 * New/updated tests: aschiffler at ferzkopp dot net
3 */
4#include <SDL3/SDL.h>
5#include <SDL3/SDL_test.h>
6#include "testautomation_suites.h"
7
8/* ================= Test Case Implementation ================== */
9
10static int clipboard_update_count;
11
12static bool SDLCALL ClipboardEventWatch(void *userdata, SDL_Event *event)
13{
14    if (event->type == SDL_EVENT_CLIPBOARD_UPDATE) {
15        ++clipboard_update_count;
16    }
17    return true;
18}
19
20enum
21{
22    TEST_MIME_TYPE_TEXT,
23    TEST_MIME_TYPE_CUSTOM_TEXT,
24    TEST_MIME_TYPE_DATA,
25    NUM_TEST_MIME_TYPES
26};
27static const char *test_mime_types[] = {
28    "text/plain;charset=utf-8",
29    "test/text",
30    "test/data"
31};
32SDL_COMPILE_TIME_ASSERT(test_mime_types, SDL_arraysize(test_mime_types) == NUM_TEST_MIME_TYPES);
33
34typedef struct
35{
36    const void *data;
37    size_t data_size;
38} TestClipboardData;
39
40static int clipboard_callback_count;
41
42static const void * SDLCALL ClipboardDataCallback(void *userdata, const char *mime_type, size_t *length)
43{
44    TestClipboardData *test_data = (TestClipboardData *)userdata;
45
46    ++clipboard_callback_count;
47
48    if (SDL_strcmp(mime_type, test_mime_types[TEST_MIME_TYPE_TEXT]) == 0) {
49        /* We're returning the string "TEST", with no termination */
50        static const char *test_text = "XXX TEST XXX";
51        *length = 4;
52        return test_text + 4;
53    }
54    if (SDL_strcmp(mime_type, test_mime_types[TEST_MIME_TYPE_CUSTOM_TEXT]) == 0) {
55        /* We're returning the string "CUSTOM", with no termination */
56        static const char *custom_text = "XXX CUSTOM XXX";
57        *length = 6;
58        return custom_text + 4;
59    }
60    if (SDL_strcmp(mime_type, test_mime_types[TEST_MIME_TYPE_DATA]) == 0) {
61        *length = test_data->data_size;
62        return test_data->data;
63    }
64    return NULL;
65}
66
67static int clipboard_cleanup_count;
68
69static void SDLCALL ClipboardCleanupCallback(void *userdata)
70{
71    ++clipboard_cleanup_count;
72}
73
74/* Test case functions */
75
76/**
77 * End-to-end test of SDL_xyzClipboardData functions
78 * \sa SDL_HasClipboardData
79 * \sa SDL_GetClipboardData
80 * \sa SDL_SetClipboardData
81 */
82static int SDLCALL clipboard_testClipboardDataFunctions(void *arg)
83{
84    int result = -1;
85    bool boolResult;
86    int last_clipboard_update_count;
87    int last_clipboard_callback_count;
88    int last_clipboard_cleanup_count;
89    void *data;
90    size_t size;
91    char *text;
92    const char *expected_text;
93
94    TestClipboardData test_data1 = {
95        &test_data1,
96        sizeof(test_data1)
97    };
98    TestClipboardData test_data2 = {
99        &last_clipboard_callback_count,
100        sizeof(last_clipboard_callback_count)
101    };
102
103    SDL_AddEventWatch(ClipboardEventWatch, NULL);
104
105    /* Test clearing clipboard data */
106    result = SDL_ClearClipboardData();
107    SDLTest_AssertCheck(
108        result == true,
109        "Validate SDL_ClearClipboardData result, expected true, got %i",
110        result);
111    expected_text = "";
112    text = SDL_GetClipboardText();
113    SDLTest_AssertCheck(
114        text && SDL_strcmp(text, expected_text) == 0,
115        "Verify clipboard text, expected \"%s\", got \"%s\"",
116        expected_text, text);
117    SDL_free(text);
118
119    /* Test clearing clipboard data when it's already clear */
120    last_clipboard_update_count = clipboard_update_count;
121    result = SDL_ClearClipboardData();
122    SDLTest_AssertCheck(
123        result == true,
124        "Validate SDL_ClearClipboardData result, expected true, got %i",
125        result);
126    SDLTest_AssertCheck(
127        clipboard_update_count != last_clipboard_update_count,
128        "Verify clipboard update count changed, got %d",
129        clipboard_update_count - last_clipboard_update_count);
130
131    /* Validate error handling */
132    last_clipboard_update_count = clipboard_update_count;
133    result = SDL_SetClipboardData(NULL, NULL, NULL, test_mime_types, SDL_arraysize(test_mime_types));
134    SDLTest_AssertCheck(
135        result == false,
136        "Validate SDL_SetClipboardData(invalid) result, expected false, got %i",
137        result);
138    SDLTest_AssertCheck(
139        clipboard_update_count == last_clipboard_update_count,
140        "Verify clipboard update count unchanged, got %d",
141        clipboard_update_count - last_clipboard_update_count);
142
143    last_clipboard_update_count = clipboard_update_count;
144    result = SDL_SetClipboardData(ClipboardDataCallback, ClipboardCleanupCallback, NULL, NULL, 0);
145    SDLTest_AssertCheck(
146        result == false,
147        "Validate SDL_SetClipboardData(invalid) result, expected false, got %i",
148        result);
149    SDLTest_AssertCheck(
150        clipboard_update_count == last_clipboard_update_count,
151        "Verify clipboard update count unchanged, got %d",
152        clipboard_update_count - last_clipboard_update_count);
153
154    /* Test setting and getting clipboard data */
155    last_clipboard_update_count = clipboard_update_count;
156    last_clipboard_callback_count = clipboard_callback_count;
157    last_clipboard_cleanup_count = clipboard_cleanup_count;
158    result = SDL_SetClipboardData(ClipboardDataCallback, ClipboardCleanupCallback, &test_data1, test_mime_types, SDL_arraysize(test_mime_types));
159    SDLTest_AssertCheck(
160        result == true,
161        "Validate SDL_SetClipboardData(test_data1) result, expected true, got %i",
162        result);
163    SDLTest_AssertCheck(
164        clipboard_update_count == last_clipboard_update_count + 1,
165        "Verify clipboard update count incremented by 1, got %d",
166        clipboard_update_count - last_clipboard_update_count);
167    SDLTest_AssertCheck(
168        clipboard_cleanup_count == last_clipboard_cleanup_count,
169        "Verify clipboard cleanup count unchanged, got %d",
170        clipboard_cleanup_count - last_clipboard_cleanup_count);
171
172    expected_text = "TEST";
173    text = SDL_GetClipboardText();
174    SDLTest_AssertCheck(
175        text && SDL_strcmp(text, expected_text) == 0,
176        "Verify clipboard text, expected \"%s\", got \"%s\"",
177        expected_text, text);
178    SDL_free(text);
179
180    boolResult = SDL_HasClipboardData(test_mime_types[TEST_MIME_TYPE_TEXT]);
181    SDLTest_AssertCheck(
182        boolResult,
183        "Verify has test text data, expected true, got false");
184    text = SDL_GetClipboardData(test_mime_types[TEST_MIME_TYPE_TEXT], &size);
185    SDLTest_AssertCheck(
186        text != NULL,
187        "Verify has test text data, expected valid result, got NULL");
188    if (text) {
189        SDLTest_AssertCheck(
190            text[size] == '\0',
191            "Verify test text data, expected null termination, got %c",
192            text[size]);
193        SDLTest_AssertCheck(
194            SDL_strcmp(text, expected_text) == 0,
195            "Verify test text data, expected \"%s\", got \"%s\"",
196            expected_text, text);
197    }
198    SDLTest_AssertCheck(
199        size == SDL_strlen(expected_text),
200        "Verify test text size, expected %d, got %d",
201        (int)SDL_strlen(expected_text), (int)size);
202    SDL_free(text);
203
204    expected_text = "CUSTOM";
205    boolResult = SDL_HasClipboardData(test_mime_types[TEST_MIME_TYPE_CUSTOM_TEXT]);
206    SDLTest_AssertCheck(
207        boolResult,
208        "Verify has test text data, expected true, got false");
209    text = SDL_GetClipboardData(test_mime_types[TEST_MIME_TYPE_CUSTOM_TEXT], &size);
210    SDLTest_AssertCheck(
211        text != NULL,
212        "Verify has test text data, expected valid result, got NULL");
213    if (text) {
214        SDLTest_AssertCheck(
215            text[size] == '\0',
216            "Verify test text data, expected null termination, got %c",
217            text[size]);
218        SDLTest_AssertCheck(
219            SDL_strcmp(text, expected_text) == 0,
220            "Verify test text data, expected \"%s\", got \"%s\"",
221            expected_text, text);
222    }
223    SDLTest_AssertCheck(
224        size == SDL_strlen(expected_text),
225        "Verify test text size, expected %d, got %d",
226        (int)SDL_strlen(expected_text), (int)size);
227    SDL_free(text);
228
229    boolResult = SDL_HasClipboardData(test_mime_types[TEST_MIME_TYPE_DATA]);
230    SDLTest_AssertCheck(
231        boolResult,
232        "Verify has test text data, expected true, got false");
233    data = SDL_GetClipboardData(test_mime_types[TEST_MIME_TYPE_DATA], &size);
234    SDLTest_AssertCheck(
235        data && SDL_memcmp(data, test_data1.data, test_data1.data_size) == 0,
236        "Verify test data");
237    SDLTest_AssertCheck(
238        size == test_data1.data_size,
239        "Verify test data size, expected %d, got %d",
240        (int)test_data1.data_size, (int)size);
241    SDL_free(data);
242
243    boolResult = SDL_HasClipboardData("test/invalid");
244    SDLTest_AssertCheck(
245        !boolResult,
246        "Verify has test text data, expected false, got true");
247    data = SDL_GetClipboardData("test/invalid", &size);
248    SDLTest_AssertCheck(
249        data == NULL,
250        "Verify invalid data, expected NULL, got %p",
251        data);
252    SDLTest_AssertCheck(
253        size == 0,
254        "Verify invalid data size, expected 0, got %d",
255        (int)size);
256    SDL_free(data);
257
258#if 0 /* There's no guarantee how or when the callback is called */
259    SDLTest_AssertCheck(
260        (clipboard_callback_count == last_clipboard_callback_count + 3) ||
261        (clipboard_callback_count == last_clipboard_callback_count + 4),
262        "Verify clipboard callback count incremented by 3 or 4, got %d",
263        clipboard_callback_count - last_clipboard_callback_count);
264#endif
265
266    /* Test setting and getting clipboard data again */
267    last_clipboard_update_count = clipboard_update_count;
268    last_clipboard_callback_count = clipboard_callback_count;
269    last_clipboard_cleanup_count = clipboard_cleanup_count;
270    result = SDL_SetClipboardData(ClipboardDataCallback, ClipboardCleanupCallback, &test_data2, test_mime_types, SDL_arraysize(test_mime_types));
271    SDLTest_AssertCheck(
272        result == true,
273        "Validate SDL_SetClipboardData(test_data2) result, expected true, got %i",
274        result);
275    SDLTest_AssertCheck(
276        clipboard_update_count == last_clipboard_update_count + 1,
277        "Verify clipboard update count incremented by 1, got %d",
278        clipboard_update_count - last_clipboard_update_count);
279    SDLTest_AssertCheck(
280        clipboard_cleanup_count == last_clipboard_cleanup_count + 1,
281        "Verify clipboard cleanup count incremented by 1, got %d",
282        clipboard_cleanup_count - last_clipboard_cleanup_count);
283
284    expected_text = "TEST";
285    text = SDL_GetClipboardText();
286    SDLTest_AssertCheck(
287        text && SDL_strcmp(text, expected_text) == 0,
288        "Verify clipboard text, expected \"%s\", got \"%s\"",
289        expected_text, text);
290    SDL_free(text);
291
292    boolResult = SDL_HasClipboardData(test_mime_types[TEST_MIME_TYPE_TEXT]);
293    SDLTest_AssertCheck(
294        boolResult,
295        "Verify has test text data, expected true, got false");
296    text = SDL_GetClipboardData(test_mime_types[TEST_MIME_TYPE_TEXT], &size);
297    SDLTest_AssertCheck(
298        text != NULL,
299        "Verify has test text data, expected valid result, got NULL");
300    if (text) {
301        SDLTest_AssertCheck(
302            text[size] == '\0',
303            "Verify test text data, expected null termination, got %c",
304            text[size]);
305        SDLTest_AssertCheck(
306            SDL_strcmp(text, expected_text) == 0,
307            "Verify test text data, expected \"%s\", got \"%s\"",
308            expected_text, text);
309    }
310    SDLTest_AssertCheck(
311        size == SDL_strlen(expected_text),
312        "Verify test text size, expected %d, got %d",
313        (int)SDL_strlen(expected_text), (int)size);
314    SDL_free(text);
315
316    expected_text = "CUSTOM";
317    boolResult = SDL_HasClipboardData(test_mime_types[TEST_MIME_TYPE_CUSTOM_TEXT]);
318    SDLTest_AssertCheck(
319        boolResult,
320        "Verify has test text data, expected true, got false");
321    text = SDL_GetClipboardData(test_mime_types[TEST_MIME_TYPE_CUSTOM_TEXT], &size);
322    SDLTest_AssertCheck(
323        text != NULL,
324        "Verify has test text data, expected valid result, got NULL");
325    if (text) {
326        SDLTest_AssertCheck(
327            text[size] == '\0',
328            "Verify test text data, expected null termination, got %c",
329            text[size]);
330        SDLTest_AssertCheck(
331            SDL_strcmp(text, expected_text) == 0,
332            "Verify test text data, expected \"%s\", got \"%s\"",
333            expected_text, text);
334    }
335    SDLTest_AssertCheck(
336        size == SDL_strlen(expected_text),
337        "Verify test text size, expected %d, got %d",
338        (int)SDL_strlen(expected_text), (int)size);
339    SDL_free(text);
340
341    data = SDL_GetClipboardData(test_mime_types[TEST_MIME_TYPE_DATA], &size);
342    SDLTest_AssertCheck(
343        data && SDL_memcmp(data, test_data2.data, test_data2.data_size) == 0,
344        "Verify test data");
345    SDLTest_AssertCheck(
346        size == test_data2.data_size,
347        "Verify test data size, expected %d, got %d",
348        (int)test_data2.data_size, (int)size);
349    SDL_free(data);
350
351    data = SDL_GetClipboardData("test/invalid", &size);
352    SDLTest_AssertCheck(
353        data == NULL,
354        "Verify invalid data, expected NULL, got %p",
355        data);
356    SDLTest_AssertCheck(
357        size == 0,
358        "Verify invalid data size, expected 0, got %d",
359        (int)size);
360    SDL_free(data);
361
362#if 0 /* There's no guarantee how or when the callback is called */
363    SDLTest_AssertCheck(
364        (clipboard_callback_count == last_clipboard_callback_count + 3) ||
365            (clipboard_callback_count == last_clipboard_callback_count + 4),
366        "Verify clipboard callback count incremented by 3 or 4, got %d",
367        clipboard_callback_count - last_clipboard_callback_count);
368#endif
369
370    /* Test clearing clipboard data when has data */
371    last_clipboard_update_count = clipboard_update_count;
372    last_clipboard_cleanup_count = clipboard_cleanup_count;
373    result = SDL_ClearClipboardData();
374    SDLTest_AssertCheck(
375        result == true,
376        "Validate SDL_ClearClipboardData result, expected true, got %i",
377        result);
378    SDLTest_AssertCheck(
379        clipboard_update_count == last_clipboard_update_count + 1,
380        "Verify clipboard update count incremented by 1, got %d",
381        clipboard_update_count - last_clipboard_update_count);
382    SDLTest_AssertCheck(
383        clipboard_cleanup_count == last_clipboard_cleanup_count + 1,
384        "Verify clipboard cleanup count incremented by 1, got %d",
385        clipboard_cleanup_count - last_clipboard_cleanup_count);
386    boolResult = SDL_HasClipboardData(test_mime_types[TEST_MIME_TYPE_TEXT]);
387    SDLTest_AssertCheck(
388        !boolResult,
389        "Verify has test text data, expected false, got true");
390    boolResult = SDL_HasClipboardData(test_mime_types[TEST_MIME_TYPE_DATA]);
391    SDLTest_AssertCheck(
392        !boolResult,
393        "Verify has test text data, expected false, got true");
394    boolResult = SDL_HasClipboardData("test/invalid");
395    SDLTest_AssertCheck(
396        !boolResult,
397        "Verify has test text data, expected false, got true");
398
399    SDL_RemoveEventWatch(ClipboardEventWatch, NULL);
400
401    return TEST_COMPLETED;
402}
403
404/**
405 * End-to-end test of SDL_xyzClipboardText functions
406 * \sa SDL_HasClipboardText
407 * \sa SDL_GetClipboardText
408 * \sa SDL_SetClipboardText
409 */
410static int SDLCALL clipboard_testClipboardTextFunctions(void *arg)
411{
412    char *textRef = SDLTest_RandomAsciiString();
413    char *text = SDL_strdup(textRef);
414    bool boolResult;
415    char *charResult;
416    int last_clipboard_update_count;
417
418    SDL_AddEventWatch(ClipboardEventWatch, NULL);
419
420    /* Empty clipboard text */
421    last_clipboard_update_count = clipboard_update_count;
422    boolResult = SDL_SetClipboardText(NULL);
423    SDLTest_AssertCheck(
424        boolResult == true,
425        "Verify result from SDL_SetClipboardText(NULL), expected true, got %s",
426        boolResult ? "true" : "false");
427    charResult = SDL_GetClipboardText();
428    SDLTest_AssertCheck(
429        charResult && SDL_strcmp(charResult, "") == 0,
430        "Verify SDL_GetClipboardText returned \"\", got %s",
431        charResult);
432    SDL_free(charResult);
433    boolResult = SDL_HasClipboardText();
434    SDLTest_AssertCheck(
435        boolResult == false,
436        "Verify SDL_HasClipboardText returned false, got %s",
437        boolResult ? "true" : "false");
438    SDLTest_AssertCheck(
439        clipboard_update_count == last_clipboard_update_count + 1,
440        "Verify clipboard update count incremented by 1, got %d",
441        clipboard_update_count - last_clipboard_update_count);
442
443
444    /* Set clipboard text  */
445    last_clipboard_update_count = clipboard_update_count;
446    boolResult = SDL_SetClipboardText(text);
447    SDLTest_AssertCheck(
448        boolResult == true,
449        "Verify result from SDL_SetClipboardText(%s), expected true, got %s", text,
450        boolResult ? "true" : "false");
451    SDLTest_AssertCheck(
452        SDL_strcmp(textRef, text) == 0,
453        "Verify SDL_SetClipboardText did not modify input string, expected '%s', got '%s'",
454        textRef, text);
455    boolResult = SDL_HasClipboardText();
456    SDLTest_AssertCheck(
457        boolResult == true,
458        "Verify SDL_HasClipboardText returned true, got %s",
459        boolResult ? "true" : "false");
460    charResult = SDL_GetClipboardText();
461    SDLTest_AssertCheck(
462        charResult && SDL_strcmp(textRef, charResult) == 0,
463        "Verify SDL_GetClipboardText returned correct string, expected '%s', got '%s'",
464        textRef, charResult);
465    SDL_free(charResult);
466    SDLTest_AssertCheck(
467        clipboard_update_count == last_clipboard_update_count + 1,
468        "Verify clipboard update count incremented by 1, got %d",
469        clipboard_update_count - last_clipboard_update_count);
470
471    /* Reset clipboard text */
472    boolResult = SDL_SetClipboardText(NULL);
473    SDLTest_AssertCheck(
474        boolResult == true,
475        "Verify result from SDL_SetClipboardText(NULL), expected true, got %s",
476        boolResult ? "true" : "false");
477
478    /* Cleanup */
479    SDL_free(textRef);
480    SDL_free(text);
481
482    SDL_RemoveEventWatch(ClipboardEventWatch, NULL);
483
484    return TEST_COMPLETED;
485}
486
487/**
488 * End-to-end test of SDL_xyzPrimarySelectionText functions
489 * \sa SDL_HasPrimarySelectionText
490 * \sa SDL_GetPrimarySelectionText
491 * \sa SDL_SetPrimarySelectionText
492 */
493static int SDLCALL clipboard_testPrimarySelectionTextFunctions(void *arg)
494{
495    char *textRef = SDLTest_RandomAsciiString();
496    char *text = SDL_strdup(textRef);
497    bool boolResult;
498    char *charResult;
499    int last_clipboard_update_count;
500
501    SDL_AddEventWatch(ClipboardEventWatch, NULL);
502
503    /* Empty primary selection */
504    last_clipboard_update_count = clipboard_update_count;
505    boolResult = SDL_SetPrimarySelectionText(NULL);
506    SDLTest_AssertCheck(
507        boolResult == true,
508        "Verify result from SDL_SetPrimarySelectionText(NULL), expected true, got %s",
509        boolResult ? "true" : "false");
510    charResult = SDL_GetPrimarySelectionText();
511    SDLTest_AssertCheck(
512        charResult && SDL_strcmp(charResult, "") == 0,
513        "Verify SDL_GetPrimarySelectionText returned \"\", got %s",
514        charResult);
515    SDL_free(charResult);
516    boolResult = SDL_HasPrimarySelectionText();
517    SDLTest_AssertCheck(
518        boolResult == false,
519        "Verify SDL_HasPrimarySelectionText returned false, got %s",
520        boolResult ? "true" : "false");
521    SDLTest_AssertCheck(
522        clipboard_update_count == last_clipboard_update_count + 1,
523        "Verify clipboard update count incremented by 1, got %d",
524        clipboard_update_count - last_clipboard_update_count);
525
526    /* Set primary selection  */
527    last_clipboard_update_count = clipboard_update_count;
528    boolResult = SDL_SetPrimarySelectionText(text);
529    SDLTest_AssertCheck(
530        boolResult == true,
531        "Verify result from SDL_SetPrimarySelectionText(%s), expected true, got %s", text,
532        boolResult ? "true" : "false");
533    SDLTest_AssertCheck(
534        SDL_strcmp(textRef, text) == 0,
535        "Verify SDL_SetPrimarySelectionText did not modify input string, expected '%s', got '%s'",
536        textRef, text);
537    boolResult = SDL_HasPrimarySelectionText();
538    SDLTest_AssertCheck(
539        boolResult == true,
540        "Verify SDL_HasPrimarySelectionText returned true, got %s",
541        boolResult ? "true" : "false");
542    charResult = SDL_GetPrimarySelectionText();
543    SDLTest_AssertCheck(
544        charResult && SDL_strcmp(textRef, charResult) == 0,
545        "Verify SDL_GetPrimarySelectionText returned correct string, expected '%s', got '%s'",
546        textRef, charResult);
547    SDL_free(charResult);
548    SDLTest_AssertCheck(
549        clipboard_update_count == last_clipboard_update_count + 1,
550        "Verify clipboard update count incremented by 1, got %d",
551        clipboard_update_count - last_clipboard_update_count);
552
553    /* Reset primary selection */
554    boolResult = SDL_SetPrimarySelectionText(NULL);
555    SDLTest_AssertCheck(
556        boolResult == true,
557        "Verify result from SDL_SetPrimarySelectionText(NULL), expected true, got %s",
558        boolResult ? "true" : "false");
559
560    /* Cleanup */
561    SDL_free(textRef);
562    SDL_free(text);
563
564    SDL_RemoveEventWatch(ClipboardEventWatch, NULL);
565
566    return TEST_COMPLETED;
567}
568
569/* ================= Test References ================== */
570
571static const SDLTest_TestCaseReference clipboardTest1 = {
572    clipboard_testClipboardDataFunctions, "clipboard_testClipboardDataFunctions", "End-to-end test of SDL_xyzClipboardData functions", TEST_ENABLED
573};
574
575static const SDLTest_TestCaseReference clipboardTest2 = {
576    clipboard_testClipboardTextFunctions, "clipboard_testClipboardTextFunctions", "End-to-end test of SDL_xyzClipboardText functions", TEST_ENABLED
577};
578
579static const SDLTest_TestCaseReference clipboardTest3 = {
580    clipboard_testPrimarySelectionTextFunctions, "clipboard_testPrimarySelectionTextFunctions", "End-to-end test of SDL_xyzPrimarySelectionText functions", TEST_ENABLED
581};
582
583/* Sequence of Clipboard test cases */
584static const SDLTest_TestCaseReference *clipboardTests[] = {
585    &clipboardTest1, &clipboardTest2, &clipboardTest3,  NULL
586};
587
588/* Clipboard test suite (global) */
589SDLTest_TestSuiteReference clipboardTestSuite = {
590    "Clipboard",
591    NULL,
592    clipboardTests,
593    NULL
594};
595
[FILE END]
(C) 2025 0x4248
(C) 2025 4248 Media and 4248 Systems, All part of 0x4248
See LICENCE files for more information. Not all files are by 0x4248 always check Licencing.