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/moin.cgi/SDL_CreateCursor
196 * @sa http://wiki.libsdl.org/moin.cgi/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/moin.cgi/SDL_CreateColorCursor
222 * @sa http://wiki.libsdl.org/moin.cgi/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/moin.cgi/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/moin.cgi/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/moin.cgi/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/moin.cgi/SDL_GetRelativeMouseMode
360 * @sa http://wiki.libsdl.org/moin.cgi/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/moin.cgi/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[] = {-1, 0, 1, w-1, w, w+1 };
451 int yPositions[] = {-1, 0, 1, h-1, h, h+1 };
452 int x, y, i, j;
453 SDL_Window *window;
454
455 /* Create test window */
456 window = _createMouseSuiteTestWindow();
457 if (window == NULL) return TEST_ABORTED;
458
459 /* Mouse to random position inside window */
460 x = SDLTest_RandomIntegerInRange(1, w-1);
461 y = SDLTest_RandomIntegerInRange(1, h-1);
462 SDL_WarpMouseInWindow(window, x, y);
463 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
464
465 /* Same position again */
466 SDL_WarpMouseInWindow(window, x, y);
467 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
468
469 /* Mouse to various boundary positions */
470 for (i=0; i<numPositions; i++) {
471 for (j=0; j<numPositions; j++) {
472 x = xPositions[i];
473 y = yPositions[j];
474 SDL_WarpMouseInWindow(window, x, y);
475 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
476
477 /* TODO: add tracking of events and check that each call generates a mouse motion event */
478 SDL_PumpEvents();
479 SDLTest_AssertPass("SDL_PumpEvents()");
480 }
481 }
482
483
484 /* Clean up test window */
485 _destroyMouseSuiteTestWindow(window);
486
487 return TEST_COMPLETED;
488 }
489
490 /**
491 * @brief Check call to SDL_GetMouseFocus
492 *
493 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetMouseFocus
494 */
495 int
mouse_getMouseFocus(void * arg)496 mouse_getMouseFocus(void *arg)
497 {
498 const int w = MOUSE_TESTWINDOW_WIDTH, h = MOUSE_TESTWINDOW_HEIGHT;
499 int x, y;
500 SDL_Window *window;
501 SDL_Window *focusWindow;
502
503 /* Get focus - focus non-deterministic */
504 focusWindow = SDL_GetMouseFocus();
505 SDLTest_AssertPass("SDL_GetMouseFocus()");
506
507 /* Create test window */
508 window = _createMouseSuiteTestWindow();
509 if (window == NULL) return TEST_ABORTED;
510
511 /* Mouse to random position inside window */
512 x = SDLTest_RandomIntegerInRange(1, w-1);
513 y = SDLTest_RandomIntegerInRange(1, h-1);
514 SDL_WarpMouseInWindow(window, x, y);
515 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
516
517 /* Pump events to update focus state */
518 SDL_PumpEvents();
519 SDLTest_AssertPass("SDL_PumpEvents()");
520
521 /* Get focus with explicit window setup - focus deterministic */
522 focusWindow = SDL_GetMouseFocus();
523 SDLTest_AssertPass("SDL_GetMouseFocus()");
524 SDLTest_AssertCheck (focusWindow != NULL, "Check returned window value is not NULL");
525 SDLTest_AssertCheck (focusWindow == window, "Check returned window value is test window");
526
527 /* Mouse to random position outside window */
528 x = SDLTest_RandomIntegerInRange(-9, -1);
529 y = SDLTest_RandomIntegerInRange(-9, -1);
530 SDL_WarpMouseInWindow(window, x, y);
531 SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
532
533 /* Clean up test window */
534 _destroyMouseSuiteTestWindow(window);
535
536 /* Pump events to update focus state */
537 SDL_PumpEvents();
538 SDLTest_AssertPass("SDL_PumpEvents()");
539
540 /* Get focus for non-existing window */
541 focusWindow = SDL_GetMouseFocus();
542 SDLTest_AssertPass("SDL_GetMouseFocus()");
543 SDLTest_AssertCheck (focusWindow == NULL, "Check returned window value is NULL");
544
545
546 return TEST_COMPLETED;
547 }
548
549 /* ================= Test References ================== */
550
551 /* Mouse test cases */
552 static const SDLTest_TestCaseReference mouseTest1 =
553 { (SDLTest_TestCaseFp)mouse_getMouseState, "mouse_getMouseState", "Check call to SDL_GetMouseState", TEST_ENABLED };
554
555 static const SDLTest_TestCaseReference mouseTest2 =
556 { (SDLTest_TestCaseFp)mouse_getRelativeMouseState, "mouse_getRelativeMouseState", "Check call to SDL_GetRelativeMouseState", TEST_ENABLED };
557
558 static const SDLTest_TestCaseReference mouseTest3 =
559 { (SDLTest_TestCaseFp)mouse_createFreeCursor, "mouse_createFreeCursor", "Check call to SDL_CreateCursor and SDL_FreeCursor", TEST_ENABLED };
560
561 static const SDLTest_TestCaseReference mouseTest4 =
562 { (SDLTest_TestCaseFp)mouse_showCursor, "mouse_showCursor", "Check call to SDL_ShowCursor", TEST_ENABLED };
563
564 static const SDLTest_TestCaseReference mouseTest5 =
565 { (SDLTest_TestCaseFp)mouse_setCursor, "mouse_setCursor", "Check call to SDL_SetCursor", TEST_ENABLED };
566
567 static const SDLTest_TestCaseReference mouseTest6 =
568 { (SDLTest_TestCaseFp)mouse_getCursor, "mouse_getCursor", "Check call to SDL_GetCursor", TEST_ENABLED };
569
570 static const SDLTest_TestCaseReference mouseTest7 =
571 { (SDLTest_TestCaseFp)mouse_warpMouseInWindow, "mouse_warpMouseInWindow", "Check call to SDL_WarpMouseInWindow", TEST_ENABLED };
572
573 static const SDLTest_TestCaseReference mouseTest8 =
574 { (SDLTest_TestCaseFp)mouse_getMouseFocus, "mouse_getMouseFocus", "Check call to SDL_getMouseFocus", TEST_ENABLED };
575
576 static const SDLTest_TestCaseReference mouseTest9 =
577 { (SDLTest_TestCaseFp)mouse_createFreeColorCursor, "mouse_createFreeColorCursor", "Check call to SDL_CreateColorCursor and SDL_FreeCursor", TEST_ENABLED };
578
579 static const SDLTest_TestCaseReference mouseTest10 =
580 { (SDLTest_TestCaseFp)mouse_getSetRelativeMouseMode, "mouse_getSetRelativeMouseMode", "Check call to SDL_GetRelativeMouseMode and SDL_SetRelativeMouseMode", TEST_ENABLED };
581
582 /* Sequence of Mouse test cases */
583 static const SDLTest_TestCaseReference *mouseTests[] = {
584 &mouseTest1, &mouseTest2, &mouseTest3, &mouseTest4, &mouseTest5, &mouseTest6,
585 &mouseTest7, &mouseTest8, &mouseTest9, &mouseTest10, NULL
586 };
587
588 /* Mouse test suite (global) */
589 SDLTest_TestSuiteReference mouseTestSuite = {
590 "Mouse",
591 NULL,
592 mouseTests,
593 NULL
594 };
595