test/testautomation_mouse.c

   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 */
  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
  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
  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 */
 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
 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
 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 */
 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
 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
 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
 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
 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  */
 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  */
 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
 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/moin.cgi/SDL_GetMouseFocus
 506  */
 507 int
 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_PumpEvents();
 531     SDLTest_AssertPass("SDL_PumpEvents()");
 532
 533         /* Get focus with explicit window setup - focus deterministic */
 534     focusWindow = SDL_GetMouseFocus();
 535     SDLTest_AssertPass("SDL_GetMouseFocus()");
 536     SDLTest_AssertCheck (focusWindow != NULL, "Check returned window value is not NULL");
 537     SDLTest_AssertCheck (focusWindow == window, "Check returned window value is test window");
 538
 539     /* Mouse to random position outside window */
 540     x = SDLTest_RandomIntegerInRange(-9, -1);
 541     y = SDLTest_RandomIntegerInRange(-9, -1);
 542     SDL_WarpMouseInWindow(window, x, y);
 543     SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
 544
 545         /* Clean up test window */
 546     _destroyMouseSuiteTestWindow(window);
 547
 548     /* Pump events to update focus state */
 549     SDL_PumpEvents();
 550     SDLTest_AssertPass("SDL_PumpEvents()");
 551
 552         /* Get focus for non-existing window */
 553     focusWindow = SDL_GetMouseFocus();
 554     SDLTest_AssertPass("SDL_GetMouseFocus()");
 555     SDLTest_AssertCheck (focusWindow == NULL, "Check returned window value is NULL");
 556
 557
 558     return TEST_COMPLETED;
 559 }
 560
 561 /* ================= Test References ================== */
 562
 563 /* Mouse test cases */
 564 static const SDLTest_TestCaseReference mouseTest1 =
 565         { (SDLTest_TestCaseFp)mouse_getMouseState, "mouse_getMouseState", "Check call to SDL_GetMouseState", TEST_ENABLED };
 566
 567 static const SDLTest_TestCaseReference mouseTest2 =
 568         { (SDLTest_TestCaseFp)mouse_getRelativeMouseState, "mouse_getRelativeMouseState", "Check call to SDL_GetRelativeMouseState", TEST_ENABLED };
 569
 570 static const SDLTest_TestCaseReference mouseTest3 =
 571         { (SDLTest_TestCaseFp)mouse_createFreeCursor, "mouse_createFreeCursor", "Check call to SDL_CreateCursor and SDL_FreeCursor", TEST_ENABLED };
 572
 573 static const SDLTest_TestCaseReference mouseTest4 =
 574         { (SDLTest_TestCaseFp)mouse_showCursor, "mouse_showCursor", "Check call to SDL_ShowCursor", TEST_ENABLED };
 575
 576 static const SDLTest_TestCaseReference mouseTest5 =
 577         { (SDLTest_TestCaseFp)mouse_setCursor, "mouse_setCursor", "Check call to SDL_SetCursor", TEST_ENABLED };
 578
 579 static const SDLTest_TestCaseReference mouseTest6 =
 580         { (SDLTest_TestCaseFp)mouse_getCursor, "mouse_getCursor", "Check call to SDL_GetCursor", TEST_ENABLED };
 581
 582 static const SDLTest_TestCaseReference mouseTest7 =
 583         { (SDLTest_TestCaseFp)mouse_warpMouseInWindow, "mouse_warpMouseInWindow", "Check call to SDL_WarpMouseInWindow", TEST_ENABLED };
 584
 585 static const SDLTest_TestCaseReference mouseTest8 =
 586         { (SDLTest_TestCaseFp)mouse_getMouseFocus, "mouse_getMouseFocus", "Check call to SDL_getMouseFocus", TEST_ENABLED };
 587
 588 static const SDLTest_TestCaseReference mouseTest9 =
 589         { (SDLTest_TestCaseFp)mouse_createFreeColorCursor, "mouse_createFreeColorCursor", "Check call to SDL_CreateColorCursor and SDL_FreeCursor", TEST_ENABLED };
 590
 591 static const SDLTest_TestCaseReference mouseTest10 =
 592         { (SDLTest_TestCaseFp)mouse_getSetRelativeMouseMode, "mouse_getSetRelativeMouseMode", "Check call to SDL_GetRelativeMouseMode and SDL_SetRelativeMouseMode", TEST_ENABLED };
 593
 594 /* Sequence of Mouse test cases */
 595 static const SDLTest_TestCaseReference *mouseTests[] =  {
 596     &mouseTest1, &mouseTest2, &mouseTest3, &mouseTest4, &mouseTest5, &mouseTest6,
 597     &mouseTest7, &mouseTest8, &mouseTest9, &mouseTest10, NULL
 598 };
 599
 600 /* Mouse test suite (global) */
 601 SDLTest_TestSuiteReference mouseTestSuite = {
 602     "Mouse",
 603     NULL,
 604     mouseTests,
 605     NULL
 606 };