1 /**
2 * Mouse test suite
3 */
4
5 #include <stdio.h>
6 #include <limits.h>
7
8 #include "SDL.h"
9 #include "SDL_test.h"
10
11 /* ================= Test Case Implementation ================== */
12
13 /* Test case functions */
14
15 /* Helper to evaluate state returned from SDL_GetMouseState */
_mouseStateCheck(Uint32 state)16 int _mouseStateCheck(Uint32 state)
17 {
18 return (state == 0) ||
19 (state == SDL_BUTTON(SDL_BUTTON_LEFT)) ||
20 (state == SDL_BUTTON(SDL_BUTTON_MIDDLE)) ||
21 (state == SDL_BUTTON(SDL_BUTTON_RIGHT)) ||
22 (state == SDL_BUTTON(SDL_BUTTON_X1)) ||
23 (state == SDL_BUTTON(SDL_BUTTON_X2));
24 }
25
26 /**
27 * @brief Check call to SDL_GetMouseState
28 *
29 */
30 int
mouse_getMouseState(void * arg)31 mouse_getMouseState(void *arg)
32 {
33 int x;
34 int y;
35 Uint32 state;
36
37 /* Pump some events to update mouse state */
38 SDL_PumpEvents();
39 SDLTest_AssertPass("Call to SDL_PumpEvents()");
40
41 /* Case where x, y pointer is NULL */
42 state = SDL_GetMouseState(NULL, NULL);
43 SDLTest_AssertPass("Call to SDL_GetMouseState(NULL, NULL)");
44 SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %i", state);
45
46 /* Case where x pointer is not NULL */
47 x = INT_MIN;
48 state = SDL_GetMouseState(&x, NULL);
49 SDLTest_AssertPass("Call to SDL_GetMouseState(&x, NULL)");
50 SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
51 SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %i", state);
52
53 /* Case where y pointer is not NULL */
54 y = INT_MIN;
55 state = SDL_GetMouseState(NULL, &y);
56 SDLTest_AssertPass("Call to SDL_GetMouseState(NULL, &y)");
57 SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
58 SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %i", state);
59
60 /* Case where x and y pointer is not NULL */
61 x = INT_MIN;
62 y = INT_MIN;
63 state = SDL_GetMouseState(&x, &y);
64 SDLTest_AssertPass("Call to SDL_GetMouseState(&x, &y)");
65 SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
66 SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
67 SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %i", state);
68
69 return TEST_COMPLETED;
70 }
71
72 /**
73 * @brief Check call to SDL_GetRelativeMouseState
74 *
75 */
76 int
mouse_getRelativeMouseState(void * arg)77 mouse_getRelativeMouseState(void *arg)
78 {
79 int x;
80 int y;
81 Uint32 state;
82
83 /* Pump some events to update mouse state */
84 SDL_PumpEvents();
85 SDLTest_AssertPass("Call to SDL_PumpEvents()");
86
87 /* Case where x, y pointer is NULL */
88 state = SDL_GetRelativeMouseState(NULL, NULL);
89 SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(NULL, NULL)");
90 SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %i", state);
91
92 /* Case where x pointer is not NULL */
93 x = INT_MIN;
94 state = SDL_GetRelativeMouseState(&x, NULL);
95 SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(&x, NULL)");
96 SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
97 SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %i", state);
98
99 /* Case where y pointer is not NULL */
100 y = INT_MIN;
101 state = SDL_GetRelativeMouseState(NULL, &y);
102 SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(NULL, &y)");
103 SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
104 SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %i", state);
105
106 /* Case where x and y pointer is not NULL */
107 x = INT_MIN;
108 y = INT_MIN;
109 state = SDL_GetRelativeMouseState(&x, &y);
110 SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(&x, &y)");
111 SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
112 SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
113 SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %i", state);
114
115 return TEST_COMPLETED;
116 }
117
118
119 /* XPM definition of mouse Cursor */
120 static const char *_mouseArrowData[] = {
121 /* pixels */
122 "X ",
123 "XX ",
124 "X.X ",
125 "X..X ",
126 "X...X ",
127 "X....X ",
128 "X.....X ",
129 "X......X ",
130 "X.......X ",
131 "X........X ",
132 "X.....XXXXX ",
133 "X..X..X ",
134 "X.X X..X ",
135 "XX X..X ",
136 "X X..X ",
137 " X..X ",
138 " X..X ",
139 " X..X ",
140 " XX ",
141 " ",
142 " ",
143 " ",
144 " ",
145 " ",
146 " ",
147 " ",
148 " ",
149 " ",
150 " ",
151 " ",
152 " ",
153 " "
154 };
155
156 /* Helper that creates a new mouse cursor from an XPM */
_initArrowCursor(const char * image[])157 static SDL_Cursor *_initArrowCursor(const char *image[])
158 {
159 SDL_Cursor *cursor;
160 int i, row, col;
161 Uint8 data[4*32];
162 Uint8 mask[4*32];
163
164 i = -1;
165 for ( row=0; row<32; ++row ) {
166 for ( col=0; col<32; ++col ) {
167 if ( col % 8 ) {
168 data[i] <<= 1;
169 mask[i] <<= 1;
170 } else {
171 ++i;
172 data[i] = mask[i] = 0;
173 }
174 switch (image[row][col]) {
175 case 'X':
176 data[i] |= 0x01;
177 mask[i] |= 0x01;
178 break;
179 case '.':
180 mask[i] |= 0x01;
181 break;
182 case ' ':
183 break;
184 }
185 }
186 }
187
188 cursor = SDL_CreateCursor(data, mask, 32, 32, 0, 0);
189 return cursor;
190 }
191
192 /**
193 * @brief Check call to SDL_CreateCursor and SDL_FreeCursor
194 *
195 * @sa http://wiki.libsdl.org/SDL_CreateCursor
196 * @sa http://wiki.libsdl.org/SDL_FreeCursor
197 */
198 int
mouse_createFreeCursor(void * arg)199 mouse_createFreeCursor(void *arg)
200 {
201 SDL_Cursor *cursor;
202
203 /* Create a cursor */
204 cursor = _initArrowCursor(_mouseArrowData);
205 SDLTest_AssertPass("Call to SDL_CreateCursor()");
206 SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateCursor() is not NULL");
207 if (cursor == NULL) {
208 return TEST_ABORTED;
209 }
210
211 /* Free cursor again */
212 SDL_FreeCursor(cursor);
213 SDLTest_AssertPass("Call to SDL_FreeCursor()");
214
215 return TEST_COMPLETED;
216 }
217
218 /**
219 * @brief Check call to SDL_CreateColorCursor and SDL_FreeCursor
220 *
221 * @sa http://wiki.libsdl.org/SDL_CreateColorCursor
222 * @sa http://wiki.libsdl.org/SDL_FreeCursor
223 */
224 int
mouse_createFreeColorCursor(void * arg)225 mouse_createFreeColorCursor(void *arg)
226 {
227 SDL_Surface *face;
228 SDL_Cursor *cursor;
229
230 /* Get sample surface */
231 face = SDLTest_ImageFace();
232 SDLTest_AssertCheck(face != NULL, "Validate sample input image is not NULL");
233 if (face == NULL) return TEST_ABORTED;
234
235 /* Create a color cursor from surface */
236 cursor = SDL_CreateColorCursor(face, 0, 0);
237 SDLTest_AssertPass("Call to SDL_CreateColorCursor()");
238 SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateColorCursor() is not NULL");
239 if (cursor == NULL) {
240 SDL_FreeSurface(face);
241 return TEST_ABORTED;
242 }
243
244 /* Free cursor again */
245 SDL_FreeCursor(cursor);
246 SDLTest_AssertPass("Call to SDL_FreeCursor()");
247
248 /* Clean up */
249 SDL_FreeSurface(face);
250
251 return TEST_COMPLETED;
252 }
253
254 /* Helper that changes cursor visibility */
_changeCursorVisibility(int state)255 void _changeCursorVisibility(int state)
256 {
257 int oldState;
258 int newState;
259 int result;
260
261 oldState = SDL_ShowCursor(SDL_QUERY);
262 SDLTest_AssertPass("Call to SDL_ShowCursor(SDL_QUERY)");
263
264 result = SDL_ShowCursor(state);
265 SDLTest_AssertPass("Call to SDL_ShowCursor(%s)", (state == SDL_ENABLE) ? "SDL_ENABLE" : "SDL_DISABLE");
266 SDLTest_AssertCheck(result == oldState, "Validate result from SDL_ShowCursor(%s), expected: %i, got: %i",
267 (state == SDL_ENABLE) ? "SDL_ENABLE" : "SDL_DISABLE", oldState, result);
268
269 newState = SDL_ShowCursor(SDL_QUERY);
270 SDLTest_AssertPass("Call to SDL_ShowCursor(SDL_QUERY)");
271 SDLTest_AssertCheck(state == newState, "Validate new state, expected: %i, got: %i",
272 state, newState);
273 }
274
275 /**
276 * @brief Check call to SDL_ShowCursor
277 *
278 * @sa http://wiki.libsdl.org/SDL_ShowCursor
279 */
280 int
mouse_showCursor(void * arg)281 mouse_showCursor(void *arg)
282 {
283 int currentState;
284
285 /* Get current state */
286 currentState = SDL_ShowCursor(SDL_QUERY);
287 SDLTest_AssertPass("Call to SDL_ShowCursor(SDL_QUERY)");
288 SDLTest_AssertCheck(currentState == SDL_DISABLE || currentState == SDL_ENABLE,
289 "Validate result is %i or %i, got: %i", SDL_DISABLE, SDL_ENABLE, currentState);
290 if (currentState == SDL_DISABLE) {
291 /* Show the cursor, then hide it again */
292 _changeCursorVisibility(SDL_ENABLE);
293 _changeCursorVisibility(SDL_DISABLE);
294 } else if (currentState == SDL_ENABLE) {
295 /* Hide the cursor, then show it again */
296 _changeCursorVisibility(SDL_DISABLE);
297 _changeCursorVisibility(SDL_ENABLE);
298 } else {
299 return TEST_ABORTED;
300 }
301
302 return TEST_COMPLETED;
303 }
304
305 /**
306 * @brief Check call to SDL_SetCursor
307 *
308 * @sa http://wiki.libsdl.org/SDL_SetCursor
309 */
310 int
mouse_setCursor(void * arg)311 mouse_setCursor(void *arg)
312 {
313 SDL_Cursor *cursor;
314
315 /* Create a cursor */
316 cursor = _initArrowCursor(_mouseArrowData);
317 SDLTest_AssertPass("Call to SDL_CreateCursor()");
318 SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateCursor() is not NULL");
319 if (cursor == NULL) {
320 return TEST_ABORTED;
321 }
322
323 /* Set the arrow cursor */
324 SDL_SetCursor(cursor);
325 SDLTest_AssertPass("Call to SDL_SetCursor(cursor)");
326
327 /* Force redraw */
328 SDL_SetCursor(NULL);
329 SDLTest_AssertPass("Call to SDL_SetCursor(NULL)");
330
331 /* Free cursor again */
332 SDL_FreeCursor(cursor);
333 SDLTest_AssertPass("Call to SDL_FreeCursor()");
334
335 return TEST_COMPLETED;
336 }
337
338 /**
339 * @brief Check call to SDL_GetCursor
340 *
341 * @sa http://wiki.libsdl.org/SDL_GetCursor
342 */
343 int
mouse_getCursor(void * arg)344 mouse_getCursor(void *arg)
345 {
346 SDL_Cursor *cursor;
347
348 /* Get current cursor */
349 cursor = SDL_GetCursor();
350 SDLTest_AssertPass("Call to SDL_GetCursor()");
351 SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_GetCursor() is not NULL");
352
353 return TEST_COMPLETED;
354 }
355
356 /**
357 * @brief Check call to SDL_GetRelativeMouseMode and SDL_SetRelativeMouseMode
358 *
359 * @sa http://wiki.libsdl.org/SDL_GetRelativeMouseMode
360 * @sa http://wiki.libsdl.org/SDL_SetRelativeMouseMode
361 */
362 int
mouse_getSetRelativeMouseMode(void * arg)363 mouse_getSetRelativeMouseMode(void *arg)
364 {
365 int result;
366 int i;
367 SDL_bool initialState;
368 SDL_bool currentState;
369
370 /* Capture original state so we can revert back to it later */
371 initialState = SDL_GetRelativeMouseMode();
372 SDLTest_AssertPass("Call to SDL_GetRelativeMouseMode()");
373
374 /* Repeat twice to check D->D transition */
375 for (i=0; i<2; i++) {
376 /* Disable - should always be supported */
377 result = SDL_SetRelativeMouseMode(SDL_FALSE);
378 SDLTest_AssertPass("Call to SDL_SetRelativeMouseMode(FALSE)");
379 SDLTest_AssertCheck(result == 0, "Validate result value from SDL_SetRelativeMouseMode, expected: 0, got: %i", result);
380 currentState = SDL_GetRelativeMouseMode();
381 SDLTest_AssertPass("Call to SDL_GetRelativeMouseMode()");
382 SDLTest_AssertCheck(currentState == SDL_FALSE, "Validate current state is FALSE, got: %i", currentState);
383 }
384
385 /* Repeat twice to check D->E->E transition */
386 for (i=0; i<2; i++) {
387 /* Enable - may not be supported */
388 result = SDL_SetRelativeMouseMode(SDL_TRUE);
389 SDLTest_AssertPass("Call to SDL_SetRelativeMouseMode(TRUE)");
390 if (result != -1) {
391 SDLTest_AssertCheck(result == 0, "Validate result value from SDL_SetRelativeMouseMode, expected: 0, got: %i", result);
392 currentState = SDL_GetRelativeMouseMode();
393 SDLTest_AssertPass("Call to SDL_GetRelativeMouseMode()");
394 SDLTest_AssertCheck(currentState == SDL_TRUE, "Validate current state is TRUE, got: %i", currentState);
395 }
396 }
397
398 /* Disable to check E->D transition */
399 result = SDL_SetRelativeMouseMode(SDL_FALSE);
400 SDLTest_AssertPass("Call to SDL_SetRelativeMouseMode(FALSE)");
401 SDLTest_AssertCheck(result == 0, "Validate result value from SDL_SetRelativeMouseMode, expected: 0, got: %i", result);
402 currentState = SDL_GetRelativeMouseMode();
403 SDLTest_AssertPass("Call to SDL_GetRelativeMouseMode()");
404 SDLTest_AssertCheck(currentState == SDL_FALSE, "Validate current state is FALSE, got: %i", currentState);
405
406 /* Revert to original state - ignore result */
407 result = SDL_SetRelativeMouseMode(initialState);
408
409 return TEST_COMPLETED;
410 }
411
412 #define MOUSE_TESTWINDOW_WIDTH 320
413 #define MOUSE_TESTWINDOW_HEIGHT 200
414
415 /**
416 * Creates a test window
417 */
_createMouseSuiteTestWindow()418 SDL_Window *_createMouseSuiteTestWindow()
419 {
420 int posX = 100, posY = 100, width = MOUSE_TESTWINDOW_WIDTH, height = MOUSE_TESTWINDOW_HEIGHT;
421 SDL_Window *window;
422 window = SDL_CreateWindow("mouse_createMouseSuiteTestWindow", posX, posY, width, height, 0);
423 SDLTest_AssertPass("SDL_CreateWindow()");
424 SDLTest_AssertCheck(window != NULL, "Check SDL_CreateWindow result");
425 return window;
426 }
427
428 /*
429 * Destroy test window
430 */
_destroyMouseSuiteTestWindow(SDL_Window * window)431 void _destroyMouseSuiteTestWindow(SDL_Window *window)
432 {
433 if (window != NULL) {
434 SDL_DestroyWindow(window);
435 window = NULL;
436 SDLTest_AssertPass("SDL_DestroyWindow()");
437 }
438 }
439
440 /**
441 * @brief Check call to SDL_WarpMouseInWindow
442 *
443 * @sa http://wiki.libsdl.org/SDL_WarpMouseInWindow
444 */
445 int
mouse_warpMouseInWindow(void * arg)446 mouse_warpMouseInWindow(void *arg)
447 {
448 const int w = MOUSE_TESTWINDOW_WIDTH, h = MOUSE_TESTWINDOW_HEIGHT;
449 int numPositions = 6;
450 int xPositions[6];
451 int yPositions[6];
452 int x, y, i, j;
453 SDL_Window *window;
454
455 xPositions[0] = -1;
456 xPositions[1] = 0;
457 xPositions[2] = 1;
458 xPositions[3] = w-1;
459 xPositions[4] = w;
460 xPositions[5] = w+1;
461 yPositions[0] = -1;
462 yPositions[1] = 0;
463 yPositions[2] = 1;
464 yPositions[3] = h-1;
465 yPositions[4] = h;
466 yPositions[5] = h+1;
467 /* Create test window */
468 window = _createMouseSuiteTestWindow();
469 if (window == NULL) return TEST_ABORTED;
470
471 /* Mouse to random position inside window */
472 x = SDLTest_RandomIntegerInRange(1, w-1);
473 y = SDLTest_RandomIntegerInRange(1, h-1);
474 SDL_WarpMouseInWindow(window, x, y);
475 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
476
477 /* Same position again */
478 SDL_WarpMouseInWindow(window, x, y);
479 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
480
481 /* Mouse to various boundary positions */
482 for (i=0; i<numPositions; i++) {
483 for (j=0; j<numPositions; j++) {
484 x = xPositions[i];
485 y = yPositions[j];
486 SDL_WarpMouseInWindow(window, x, y);
487 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
488
489 /* TODO: add tracking of events and check that each call generates a mouse motion event */
490 SDL_PumpEvents();
491 SDLTest_AssertPass("SDL_PumpEvents()");
492 }
493 }
494
495
496 /* Clean up test window */
497 _destroyMouseSuiteTestWindow(window);
498
499 return TEST_COMPLETED;
500 }
501
502 /**
503 * @brief Check call to SDL_GetMouseFocus
504 *
505 * @sa http://wiki.libsdl.org/SDL_GetMouseFocus
506 */
507 int
mouse_getMouseFocus(void * arg)508 mouse_getMouseFocus(void *arg)
509 {
510 const int w = MOUSE_TESTWINDOW_WIDTH, h = MOUSE_TESTWINDOW_HEIGHT;
511 int x, y;
512 SDL_Window *window;
513 SDL_Window *focusWindow;
514
515 /* Get focus - focus non-deterministic */
516 focusWindow = SDL_GetMouseFocus();
517 SDLTest_AssertPass("SDL_GetMouseFocus()");
518
519 /* Create test window */
520 window = _createMouseSuiteTestWindow();
521 if (window == NULL) return TEST_ABORTED;
522
523 /* Mouse to random position inside window */
524 x = SDLTest_RandomIntegerInRange(1, w-1);
525 y = SDLTest_RandomIntegerInRange(1, h-1);
526 SDL_WarpMouseInWindow(window, x, y);
527 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
528
529 /* Pump events to update focus state */
530 SDL_Delay(100);
531 SDL_PumpEvents();
532 SDLTest_AssertPass("SDL_PumpEvents()");
533
534 /* Get focus with explicit window setup - focus deterministic */
535 focusWindow = SDL_GetMouseFocus();
536 SDLTest_AssertPass("SDL_GetMouseFocus()");
537 SDLTest_AssertCheck (focusWindow != NULL, "Check returned window value is not NULL");
538 SDLTest_AssertCheck (focusWindow == window, "Check returned window value is test window");
539
540 /* Mouse to random position outside window */
541 x = SDLTest_RandomIntegerInRange(-9, -1);
542 y = SDLTest_RandomIntegerInRange(-9, -1);
543 SDL_WarpMouseInWindow(window, x, y);
544 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
545
546 /* Clean up test window */
547 _destroyMouseSuiteTestWindow(window);
548
549 /* Pump events to update focus state */
550 SDL_PumpEvents();
551 SDLTest_AssertPass("SDL_PumpEvents()");
552
553 /* Get focus for non-existing window */
554 focusWindow = SDL_GetMouseFocus();
555 SDLTest_AssertPass("SDL_GetMouseFocus()");
556 SDLTest_AssertCheck (focusWindow == NULL, "Check returned window value is NULL");
557
558
559 return TEST_COMPLETED;
560 }
561
562 /* ================= Test References ================== */
563
564 /* Mouse test cases */
565 static const SDLTest_TestCaseReference mouseTest1 =
566 { (SDLTest_TestCaseFp)mouse_getMouseState, "mouse_getMouseState", "Check call to SDL_GetMouseState", TEST_ENABLED };
567
568 static const SDLTest_TestCaseReference mouseTest2 =
569 { (SDLTest_TestCaseFp)mouse_getRelativeMouseState, "mouse_getRelativeMouseState", "Check call to SDL_GetRelativeMouseState", TEST_ENABLED };
570
571 static const SDLTest_TestCaseReference mouseTest3 =
572 { (SDLTest_TestCaseFp)mouse_createFreeCursor, "mouse_createFreeCursor", "Check call to SDL_CreateCursor and SDL_FreeCursor", TEST_ENABLED };
573
574 static const SDLTest_TestCaseReference mouseTest4 =
575 { (SDLTest_TestCaseFp)mouse_showCursor, "mouse_showCursor", "Check call to SDL_ShowCursor", TEST_ENABLED };
576
577 static const SDLTest_TestCaseReference mouseTest5 =
578 { (SDLTest_TestCaseFp)mouse_setCursor, "mouse_setCursor", "Check call to SDL_SetCursor", TEST_ENABLED };
579
580 static const SDLTest_TestCaseReference mouseTest6 =
581 { (SDLTest_TestCaseFp)mouse_getCursor, "mouse_getCursor", "Check call to SDL_GetCursor", TEST_ENABLED };
582
583 static const SDLTest_TestCaseReference mouseTest7 =
584 { (SDLTest_TestCaseFp)mouse_warpMouseInWindow, "mouse_warpMouseInWindow", "Check call to SDL_WarpMouseInWindow", TEST_ENABLED };
585
586 static const SDLTest_TestCaseReference mouseTest8 =
587 { (SDLTest_TestCaseFp)mouse_getMouseFocus, "mouse_getMouseFocus", "Check call to SDL_getMouseFocus", TEST_ENABLED };
588
589 static const SDLTest_TestCaseReference mouseTest9 =
590 { (SDLTest_TestCaseFp)mouse_createFreeColorCursor, "mouse_createFreeColorCursor", "Check call to SDL_CreateColorCursor and SDL_FreeCursor", TEST_ENABLED };
591
592 static const SDLTest_TestCaseReference mouseTest10 =
593 { (SDLTest_TestCaseFp)mouse_getSetRelativeMouseMode, "mouse_getSetRelativeMouseMode", "Check call to SDL_GetRelativeMouseMode and SDL_SetRelativeMouseMode", TEST_ENABLED };
594
595 /* Sequence of Mouse test cases */
596 static const SDLTest_TestCaseReference *mouseTests[] = {
597 &mouseTest1, &mouseTest2, &mouseTest3, &mouseTest4, &mouseTest5, &mouseTest6,
598 &mouseTest7, &mouseTest8, &mouseTest9, &mouseTest10, NULL
599 };
600
601 /* Mouse test suite (global) */
602 SDLTest_TestSuiteReference mouseTestSuite = {
603 "Mouse",
604 NULL,
605 mouseTests,
606 NULL
607 };
608