test/testautomation_mouse.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 13 Aug 2017 21:15:44 -0700
changeset 11275 6dd70238edb7
parent 7191 75360622e65f
permissions -rw-r--r--
Fixed bug 3741 - more compatible initializers for arrays

Ozkan Sezer

An array defined like int xPositions[] = {-1, 0, 1, w-1, w, w+1 };
errors with Open Watcom: it strictly wants constants. Small patch
like below makes things more compatible.
     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 };