test/testautomation_keyboard.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 07 Dec 2017 16:08:09 -0800
changeset 11730 ac6c607e065c
parent 10782 1de6d4633ee6
permissions -rw-r--r--
Enable building the Metal renderer by default, and weak link the Metal framework so the SDL library is safe to use on older Macs
Also generate iOS versions of the Metal shaders
     1 /**
     2  * Keyboard test suite
     3  */
     4 
     5 #include <stdio.h>
     6 #include <limits.h>
     7 
     8 #include "SDL_config.h"
     9 #include "SDL.h"
    10 #include "SDL_test.h"
    11 
    12 /* ================= Test Case Implementation ================== */
    13 
    14 /* Test case functions */
    15 
    16 /**
    17  * @brief Check call to SDL_GetKeyboardState with and without numkeys reference.
    18  *
    19  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyboardState
    20  */
    21 int
    22 keyboard_getKeyboardState(void *arg)
    23 {
    24    int numkeys;
    25    Uint8 *state;
    26 
    27    /* Case where numkeys pointer is NULL */
    28    state = (Uint8 *)SDL_GetKeyboardState(NULL);
    29    SDLTest_AssertPass("Call to SDL_GetKeyboardState(NULL)");
    30    SDLTest_AssertCheck(state != NULL, "Validate that return value from SDL_GetKeyboardState is not NULL");
    31 
    32    /* Case where numkeys pointer is not NULL */
    33    numkeys = -1;
    34    state = (Uint8 *)SDL_GetKeyboardState(&numkeys);
    35    SDLTest_AssertPass("Call to SDL_GetKeyboardState(&numkeys)");
    36    SDLTest_AssertCheck(state != NULL, "Validate that return value from SDL_GetKeyboardState is not NULL");
    37    SDLTest_AssertCheck(numkeys >= 0, "Validate that value of numkeys is >= 0, got: %i", numkeys);
    38 
    39    return TEST_COMPLETED;
    40 }
    41 
    42 /**
    43  * @brief Check call to SDL_GetKeyboardFocus
    44  *
    45  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyboardFocus
    46  */
    47 int
    48 keyboard_getKeyboardFocus(void *arg)
    49 {
    50    SDL_Window* window;
    51 
    52    /* Call, but ignore return value */
    53    window = SDL_GetKeyboardFocus();
    54    SDLTest_AssertPass("Call to SDL_GetKeyboardFocus()");
    55 
    56    return TEST_COMPLETED;
    57 }
    58 
    59 /**
    60  * @brief Check call to SDL_GetKeyFromName for known, unknown and invalid name.
    61  *
    62  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromName
    63  */
    64 int
    65 keyboard_getKeyFromName(void *arg)
    66 {
    67    SDL_Keycode result;
    68 
    69    /* Case where Key is known, 1 character input */
    70    result = SDL_GetKeyFromName("A");
    71    SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/single)");
    72    SDLTest_AssertCheck(result == SDLK_a, "Verify result from call, expected: %i, got: %i", SDLK_a, result);
    73 
    74    /* Case where Key is known, 2 character input */
    75    result = SDL_GetKeyFromName("F1");
    76    SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/double)");
    77    SDLTest_AssertCheck(result == SDLK_F1, "Verify result from call, expected: %i, got: %i", SDLK_F1, result);
    78 
    79    /* Case where Key is known, 3 character input */
    80    result = SDL_GetKeyFromName("End");
    81    SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/triple)");
    82    SDLTest_AssertCheck(result == SDLK_END, "Verify result from call, expected: %i, got: %i", SDLK_END, result);
    83 
    84    /* Case where Key is known, 4 character input */
    85    result = SDL_GetKeyFromName("Find");
    86    SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/quad)");
    87    SDLTest_AssertCheck(result == SDLK_FIND, "Verify result from call, expected: %i, got: %i", SDLK_FIND, result);
    88 
    89    /* Case where Key is known, multiple character input */
    90    result = SDL_GetKeyFromName("AudioStop");
    91    SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/multi)");
    92    SDLTest_AssertCheck(result == SDLK_AUDIOSTOP, "Verify result from call, expected: %i, got: %i", SDLK_AUDIOSTOP, result);
    93 
    94    /* Case where Key is unknown */
    95    result = SDL_GetKeyFromName("NotThere");
    96    SDLTest_AssertPass("Call to SDL_GetKeyFromName(unknown)");
    97    SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
    98 
    99    /* Case where input is NULL/invalid */
   100    result = SDL_GetKeyFromName(NULL);
   101    SDLTest_AssertPass("Call to SDL_GetKeyFromName(NULL)");
   102    SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
   103 
   104    return TEST_COMPLETED;
   105 }
   106 
   107 /*
   108  * Local helper to check for the invalid scancode error message
   109  */
   110 void
   111 _checkInvalidScancodeError()
   112 {
   113    const char *expectedError = "Parameter 'scancode' is invalid";
   114    const char *error;
   115    error = SDL_GetError();
   116    SDLTest_AssertPass("Call to SDL_GetError()");
   117    SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
   118    if (error != NULL) {
   119       SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
   120           "Validate error message, expected: '%s', got: '%s'", expectedError, error);
   121       SDL_ClearError();
   122       SDLTest_AssertPass("Call to SDL_ClearError()");
   123    }
   124 }
   125 
   126 /**
   127  * @brief Check call to SDL_GetKeyFromScancode
   128  *
   129  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromScancode
   130  */
   131 int
   132 keyboard_getKeyFromScancode(void *arg)
   133 {
   134    SDL_Keycode result;
   135 
   136    /* Case where input is valid */
   137    result = SDL_GetKeyFromScancode(SDL_SCANCODE_A);
   138    SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(valid)");
   139    SDLTest_AssertCheck(result == SDLK_a, "Verify result from call, expected: %i, got: %i", SDLK_a, result);
   140 
   141    /* Case where input is zero */
   142    result = SDL_GetKeyFromScancode(0);
   143    SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(0)");
   144    SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
   145 
   146    /* Clear error message */
   147    SDL_ClearError();
   148    SDLTest_AssertPass("Call to SDL_ClearError()");
   149 
   150    /* Case where input is invalid (too small) */
   151    result = SDL_GetKeyFromScancode(-999);
   152    SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(-999)");
   153    SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
   154    _checkInvalidScancodeError();
   155 
   156    /* Case where input is invalid (too big) */
   157    result = SDL_GetKeyFromScancode(999);
   158    SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(999)");
   159    SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
   160    _checkInvalidScancodeError();
   161 
   162    return TEST_COMPLETED;
   163 }
   164 
   165 /**
   166  * @brief Check call to SDL_GetKeyName
   167  *
   168  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyName
   169  */
   170 int
   171 keyboard_getKeyName(void *arg)
   172 {
   173    char *result;
   174    char *expected;
   175 
   176    /* Case where key has a 1 character name */
   177    expected = "3";
   178    result = (char *)SDL_GetKeyName(SDLK_3);
   179    SDLTest_AssertPass("Call to SDL_GetKeyName()");
   180    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   181    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
   182 
   183    /* Case where key has a 2 character name */
   184    expected = "F1";
   185    result = (char *)SDL_GetKeyName(SDLK_F1);
   186    SDLTest_AssertPass("Call to SDL_GetKeyName()");
   187    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   188    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
   189 
   190    /* Case where key has a 3 character name */
   191    expected = "Cut";
   192    result = (char *)SDL_GetKeyName(SDLK_CUT);
   193    SDLTest_AssertPass("Call to SDL_GetKeyName()");
   194    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   195    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
   196 
   197    /* Case where key has a 4 character name */
   198    expected = "Down";
   199    result = (char *)SDL_GetKeyName(SDLK_DOWN);
   200    SDLTest_AssertPass("Call to SDL_GetKeyName()");
   201    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   202    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
   203 
   204    /* Case where key has a N character name */
   205    expected = "BrightnessUp";
   206    result = (char *)SDL_GetKeyName(SDLK_BRIGHTNESSUP);
   207    SDLTest_AssertPass("Call to SDL_GetKeyName()");
   208    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   209    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
   210 
   211    /* Case where key has a N character name with space */
   212    expected = "Keypad MemStore";
   213    result = (char *)SDL_GetKeyName(SDLK_KP_MEMSTORE);
   214    SDLTest_AssertPass("Call to SDL_GetKeyName()");
   215    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   216    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
   217 
   218    return TEST_COMPLETED;
   219 }
   220 
   221 /**
   222  * @brief SDL_GetScancodeName negative cases
   223  *
   224  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeName
   225  */
   226 int
   227 keyboard_getScancodeNameNegative(void *arg)
   228 {
   229    SDL_Scancode scancode;
   230    char *result;
   231    char *expected = "";
   232 
   233    /* Clear error message */
   234    SDL_ClearError();
   235    SDLTest_AssertPass("Call to SDL_ClearError()");
   236 
   237    /* Out-of-bounds scancode */
   238    scancode = (SDL_Scancode)SDL_NUM_SCANCODES;
   239    result = (char *)SDL_GetScancodeName(scancode);
   240    SDLTest_AssertPass("Call to SDL_GetScancodeName(%d/large)", scancode);
   241    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   242    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result);
   243    _checkInvalidScancodeError();
   244 
   245    return TEST_COMPLETED;
   246 }
   247 
   248 /**
   249  * @brief SDL_GetKeyName negative cases
   250  *
   251  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyName
   252  */
   253 int
   254 keyboard_getKeyNameNegative(void *arg)
   255 {
   256    SDL_Keycode keycode;
   257    char *result;
   258    char *expected = "";
   259 
   260    /* Unknown keycode */
   261    keycode = SDLK_UNKNOWN;
   262    result = (char *)SDL_GetKeyName(keycode);
   263    SDLTest_AssertPass("Call to SDL_GetKeyName(%d/unknown)", keycode);
   264    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   265    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result);
   266 
   267    /* Clear error message */
   268    SDL_ClearError();
   269    SDLTest_AssertPass("Call to SDL_ClearError()");
   270 
   271    /* Negative keycode */
   272    keycode = (SDL_Keycode)SDLTest_RandomIntegerInRange(-255, -1);
   273    result = (char *)SDL_GetKeyName(keycode);
   274    SDLTest_AssertPass("Call to SDL_GetKeyName(%d/negative)", keycode);
   275    SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
   276    SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result);
   277    _checkInvalidScancodeError();
   278 
   279    SDL_ClearError();
   280    SDLTest_AssertPass("Call to SDL_ClearError()");
   281 
   282    return TEST_COMPLETED;
   283 }
   284 
   285 /**
   286  * @brief Check call to SDL_GetModState and SDL_SetModState
   287  *
   288  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetModState
   289  * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetModState
   290  */
   291 int
   292 keyboard_getSetModState(void *arg)
   293 {
   294    SDL_Keymod result;
   295    SDL_Keymod currentState;
   296    SDL_Keymod newState;
   297    SDL_Keymod allStates =
   298     KMOD_NONE |
   299     KMOD_LSHIFT |
   300     KMOD_RSHIFT |
   301     KMOD_LCTRL |
   302     KMOD_RCTRL |
   303     KMOD_LALT |
   304     KMOD_RALT |
   305     KMOD_LGUI |
   306     KMOD_RGUI |
   307     KMOD_NUM |
   308     KMOD_CAPS |
   309     KMOD_MODE |
   310     KMOD_RESERVED;
   311 
   312    /* Get state, cache for later reset */
   313    result = SDL_GetModState();
   314    SDLTest_AssertPass("Call to SDL_GetModState()");
   315    SDLTest_AssertCheck(/*result >= 0 &&*/ result <= allStates, "Verify result from call is valid, expected: 0 <= result <= %i, got: %i", allStates, result);
   316    currentState = result;
   317 
   318    /* Set random state */
   319    newState = SDLTest_RandomIntegerInRange(0, allStates);
   320    SDL_SetModState(newState);
   321    SDLTest_AssertPass("Call to SDL_SetModState(%i)", newState);
   322    result = SDL_GetModState();
   323    SDLTest_AssertPass("Call to SDL_GetModState()");
   324    SDLTest_AssertCheck(result == newState, "Verify result from call is valid, expected: %i, got: %i", newState, result);
   325 
   326    /* Set zero state */
   327    SDL_SetModState(0);
   328    SDLTest_AssertPass("Call to SDL_SetModState(0)");
   329    result = SDL_GetModState();
   330    SDLTest_AssertPass("Call to SDL_GetModState()");
   331    SDLTest_AssertCheck(result == 0, "Verify result from call is valid, expected: 0, got: %i", result);
   332 
   333    /* Revert back to cached current state if needed */
   334    if (currentState != 0) {
   335      SDL_SetModState(currentState);
   336      SDLTest_AssertPass("Call to SDL_SetModState(%i)", currentState);
   337      result = SDL_GetModState();
   338      SDLTest_AssertPass("Call to SDL_GetModState()");
   339      SDLTest_AssertCheck(result == currentState, "Verify result from call is valid, expected: %i, got: %i", currentState, result);
   340    }
   341 
   342    return TEST_COMPLETED;
   343 }
   344 
   345 
   346 /**
   347  * @brief Check call to SDL_StartTextInput and SDL_StopTextInput
   348  *
   349  * @sa http://wiki.libsdl.org/moin.cgi/SDL_StartTextInput
   350  * @sa http://wiki.libsdl.org/moin.cgi/SDL_StopTextInput
   351  */
   352 int
   353 keyboard_startStopTextInput(void *arg)
   354 {
   355    /* Start-Stop */
   356    SDL_StartTextInput();
   357    SDLTest_AssertPass("Call to SDL_StartTextInput()");
   358    SDL_StopTextInput();
   359    SDLTest_AssertPass("Call to SDL_StopTextInput()");
   360 
   361    /* Stop-Start */
   362    SDL_StartTextInput();
   363    SDLTest_AssertPass("Call to SDL_StartTextInput()");
   364 
   365    /* Start-Start */
   366    SDL_StartTextInput();
   367    SDLTest_AssertPass("Call to SDL_StartTextInput()");
   368 
   369    /* Stop-Stop */
   370    SDL_StopTextInput();
   371    SDLTest_AssertPass("Call to SDL_StopTextInput()");
   372    SDL_StopTextInput();
   373    SDLTest_AssertPass("Call to SDL_StopTextInput()");
   374 
   375    return TEST_COMPLETED;
   376 }
   377 
   378 /* Internal function to test SDL_SetTextInputRect */
   379 void _testSetTextInputRect(SDL_Rect refRect)
   380 {
   381    SDL_Rect testRect;
   382 
   383    testRect = refRect;
   384    SDL_SetTextInputRect(&testRect);
   385    SDLTest_AssertPass("Call to SDL_SetTextInputRect with refRect(x:%i,y:%i,w:%i,h:%i)", refRect.x, refRect.y, refRect.w, refRect.h);
   386    SDLTest_AssertCheck(
   387       (refRect.x == testRect.x) && (refRect.y == testRect.y) && (refRect.w == testRect.w) && (refRect.h == testRect.h),
   388       "Check that input data was not modified, expected: x:%i,y:%i,w:%i,h:%i, got: x:%i,y:%i,w:%i,h:%i",
   389       refRect.x, refRect.y, refRect.w, refRect.h,
   390       testRect.x, testRect.y, testRect.w, testRect.h);
   391 }
   392 
   393 /**
   394  * @brief Check call to SDL_SetTextInputRect
   395  *
   396  * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetTextInputRect
   397  */
   398 int
   399 keyboard_setTextInputRect(void *arg)
   400 {
   401    SDL_Rect refRect;
   402 
   403    /* Normal visible refRect, origin inside */
   404    refRect.x = SDLTest_RandomIntegerInRange(1, 50);
   405    refRect.y = SDLTest_RandomIntegerInRange(1, 50);
   406    refRect.w = SDLTest_RandomIntegerInRange(10, 50);
   407    refRect.h = SDLTest_RandomIntegerInRange(10, 50);
   408    _testSetTextInputRect(refRect);
   409 
   410    /* Normal visible refRect, origin 0,0 */
   411    refRect.x = 0;
   412    refRect.y = 0;
   413    refRect.w = SDLTest_RandomIntegerInRange(10, 50);
   414    refRect.h = SDLTest_RandomIntegerInRange(10, 50);
   415    _testSetTextInputRect(refRect);
   416 
   417    /* 1Pixel refRect */
   418    refRect.x = SDLTest_RandomIntegerInRange(10, 50);
   419    refRect.y = SDLTest_RandomIntegerInRange(10, 50);
   420    refRect.w = 1;
   421    refRect.h = 1;
   422    _testSetTextInputRect(refRect);
   423 
   424    /* 0pixel refRect */
   425    refRect.x = 1;
   426    refRect.y = 1;
   427    refRect.w = 1;
   428    refRect.h = 0;
   429    _testSetTextInputRect(refRect);
   430 
   431    /* 0pixel refRect */
   432    refRect.x = 1;
   433    refRect.y = 1;
   434    refRect.w = 0;
   435    refRect.h = 1;
   436    _testSetTextInputRect(refRect);
   437 
   438    /* 0pixel refRect */
   439    refRect.x = 1;
   440    refRect.y = 1;
   441    refRect.w = 0;
   442    refRect.h = 0;
   443    _testSetTextInputRect(refRect);
   444 
   445    /* 0pixel refRect */
   446    refRect.x = 0;
   447    refRect.y = 0;
   448    refRect.w = 0;
   449    refRect.h = 0;
   450    _testSetTextInputRect(refRect);
   451 
   452    /* negative refRect */
   453    refRect.x = SDLTest_RandomIntegerInRange(-200, -100);
   454    refRect.y = SDLTest_RandomIntegerInRange(-200, -100);
   455    refRect.w = 50;
   456    refRect.h = 50;
   457    _testSetTextInputRect(refRect);
   458 
   459    /* oversized refRect */
   460    refRect.x = SDLTest_RandomIntegerInRange(1, 50);
   461    refRect.y = SDLTest_RandomIntegerInRange(1, 50);
   462    refRect.w = 5000;
   463    refRect.h = 5000;
   464    _testSetTextInputRect(refRect);
   465 
   466    /* NULL refRect */
   467    SDL_SetTextInputRect(NULL);
   468    SDLTest_AssertPass("Call to SDL_SetTextInputRect(NULL)");
   469 
   470    return TEST_COMPLETED;
   471 }
   472 
   473 /**
   474  * @brief Check call to SDL_SetTextInputRect with invalid data
   475  *
   476  * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetTextInputRect
   477  */
   478 int
   479 keyboard_setTextInputRectNegative(void *arg)
   480 {
   481    /* Some platforms set also an error message; prepare for checking it */
   482 #if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_ANDROID || SDL_VIDEO_DRIVER_COCOA
   483    const char *expectedError = "Parameter 'rect' is invalid";
   484    const char *error;
   485 
   486    SDL_ClearError();
   487    SDLTest_AssertPass("Call to SDL_ClearError()");
   488 #endif
   489 
   490    /* NULL refRect */
   491    SDL_SetTextInputRect(NULL);
   492    SDLTest_AssertPass("Call to SDL_SetTextInputRect(NULL)");
   493 
   494    /* Some platforms set also an error message; so check it */
   495 #if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_ANDROID || SDL_VIDEO_DRIVER_COCOA
   496    error = SDL_GetError();
   497    SDLTest_AssertPass("Call to SDL_GetError()");
   498    SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
   499    if (error != NULL) {
   500       SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
   501           "Validate error message, expected: '%s', got: '%s'", expectedError, error);
   502    }
   503 
   504    SDL_ClearError();
   505    SDLTest_AssertPass("Call to SDL_ClearError()");
   506 #endif
   507 
   508    return TEST_COMPLETED;
   509 }
   510 
   511 /**
   512  * @brief Check call to SDL_GetScancodeFromKey
   513  *
   514  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromKey
   515  * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
   516  */
   517 int
   518 keyboard_getScancodeFromKey(void *arg)
   519 {
   520    SDL_Scancode scancode;
   521 
   522    /* Regular key */
   523    scancode = SDL_GetScancodeFromKey(SDLK_4);
   524    SDLTest_AssertPass("Call to SDL_GetScancodeFromKey(SDLK_4)");
   525    SDLTest_AssertCheck(scancode == SDL_SCANCODE_4, "Validate return value from SDL_GetScancodeFromKey, expected: %i, got: %i", SDL_SCANCODE_4, scancode);
   526 
   527    /* Virtual key */
   528    scancode = SDL_GetScancodeFromKey(SDLK_PLUS);
   529    SDLTest_AssertPass("Call to SDL_GetScancodeFromKey(SDLK_PLUS)");
   530    SDLTest_AssertCheck(scancode == 0, "Validate return value from SDL_GetScancodeFromKey, expected: 0, got: %i", scancode);
   531 
   532    return TEST_COMPLETED;
   533 }
   534 
   535 /**
   536  * @brief Check call to SDL_GetScancodeFromName
   537  *
   538  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromName
   539  * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
   540  */
   541 int
   542 keyboard_getScancodeFromName(void *arg)
   543 {
   544    SDL_Scancode scancode;
   545 
   546    /* Regular key, 1 character, first name in list */
   547    scancode = SDL_GetScancodeFromName("A");
   548    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('A')");
   549    SDLTest_AssertCheck(scancode == SDL_SCANCODE_A, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_A, scancode);
   550 
   551    /* Regular key, 1 character */
   552    scancode = SDL_GetScancodeFromName("4");
   553    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('4')");
   554    SDLTest_AssertCheck(scancode == SDL_SCANCODE_4, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_4, scancode);
   555 
   556    /* Regular key, 2 characters */
   557    scancode = SDL_GetScancodeFromName("F1");
   558    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('F1')");
   559    SDLTest_AssertCheck(scancode == SDL_SCANCODE_F1, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_F1, scancode);
   560 
   561    /* Regular key, 3 characters */
   562    scancode = SDL_GetScancodeFromName("End");
   563    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('End')");
   564    SDLTest_AssertCheck(scancode == SDL_SCANCODE_END, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_END, scancode);
   565 
   566    /* Regular key, 4 characters */
   567    scancode = SDL_GetScancodeFromName("Find");
   568    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Find')");
   569    SDLTest_AssertCheck(scancode == SDL_SCANCODE_FIND, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_FIND, scancode);
   570 
   571    /* Regular key, several characters */
   572    scancode = SDL_GetScancodeFromName("Backspace");
   573    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Backspace')");
   574    SDLTest_AssertCheck(scancode == SDL_SCANCODE_BACKSPACE, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_BACKSPACE, scancode);
   575 
   576    /* Regular key, several characters with space */
   577    scancode = SDL_GetScancodeFromName("Keypad Enter");
   578    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Keypad Enter')");
   579    SDLTest_AssertCheck(scancode == SDL_SCANCODE_KP_ENTER, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_KP_ENTER, scancode);
   580 
   581    /* Regular key, last name in list */
   582    scancode = SDL_GetScancodeFromName("Sleep");
   583    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Sleep')");
   584    SDLTest_AssertCheck(scancode == SDL_SCANCODE_SLEEP, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_SLEEP, scancode);
   585 
   586    return TEST_COMPLETED;
   587 }
   588 
   589 /*
   590  * Local helper to check for the invalid scancode error message
   591  */
   592 void
   593 _checkInvalidNameError()
   594 {
   595    const char *expectedError = "Parameter 'name' is invalid";
   596    const char *error;
   597    error = SDL_GetError();
   598    SDLTest_AssertPass("Call to SDL_GetError()");
   599    SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
   600    if (error != NULL) {
   601       SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
   602           "Validate error message, expected: '%s', got: '%s'", expectedError, error);
   603       SDL_ClearError();
   604       SDLTest_AssertPass("Call to SDL_ClearError()");
   605    }
   606 }
   607 
   608 /**
   609  * @brief Check call to SDL_GetScancodeFromName with invalid data
   610  *
   611  * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromName
   612  * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
   613  */
   614 int
   615 keyboard_getScancodeFromNameNegative(void *arg)
   616 {
   617    char *name;
   618    SDL_Scancode scancode;
   619 
   620    /* Clear error message */
   621    SDL_ClearError();
   622    SDLTest_AssertPass("Call to SDL_ClearError()");
   623 
   624    /* Random string input */
   625    name = SDLTest_RandomAsciiStringOfSize(32);
   626    SDLTest_Assert(name != NULL, "Check that random name is not NULL");
   627    if (name == NULL) {
   628       return TEST_ABORTED;
   629    }
   630    scancode = SDL_GetScancodeFromName((const char *)name);
   631    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('%s')", name);
   632    SDL_free(name);
   633    SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
   634    _checkInvalidNameError();
   635 
   636    /* Zero length string input */
   637    name = "";
   638    scancode = SDL_GetScancodeFromName((const char *)name);
   639    SDLTest_AssertPass("Call to SDL_GetScancodeFromName(NULL)");
   640    SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
   641    _checkInvalidNameError();
   642 
   643    /* NULL input */
   644    name = NULL;
   645    scancode = SDL_GetScancodeFromName((const char *)name);
   646    SDLTest_AssertPass("Call to SDL_GetScancodeFromName(NULL)");
   647    SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
   648    _checkInvalidNameError();
   649 
   650    return TEST_COMPLETED;
   651 }
   652 
   653 
   654 
   655 /* ================= Test References ================== */
   656 
   657 /* Keyboard test cases */
   658 static const SDLTest_TestCaseReference keyboardTest1 =
   659         { (SDLTest_TestCaseFp)keyboard_getKeyboardState, "keyboard_getKeyboardState", "Check call to SDL_GetKeyboardState with and without numkeys reference", TEST_ENABLED };
   660 
   661 static const SDLTest_TestCaseReference keyboardTest2 =
   662         { (SDLTest_TestCaseFp)keyboard_getKeyboardFocus, "keyboard_getKeyboardFocus", "Check call to SDL_GetKeyboardFocus", TEST_ENABLED };
   663 
   664 static const SDLTest_TestCaseReference keyboardTest3 =
   665         { (SDLTest_TestCaseFp)keyboard_getKeyFromName, "keyboard_getKeyFromName", "Check call to SDL_GetKeyFromName for known, unknown and invalid name", TEST_ENABLED };
   666 
   667 static const SDLTest_TestCaseReference keyboardTest4 =
   668         { (SDLTest_TestCaseFp)keyboard_getKeyFromScancode, "keyboard_getKeyFromScancode", "Check call to SDL_GetKeyFromScancode", TEST_ENABLED };
   669 
   670 static const SDLTest_TestCaseReference keyboardTest5 =
   671         { (SDLTest_TestCaseFp)keyboard_getKeyName, "keyboard_getKeyName", "Check call to SDL_GetKeyName", TEST_ENABLED };
   672 
   673 static const SDLTest_TestCaseReference keyboardTest6 =
   674         { (SDLTest_TestCaseFp)keyboard_getSetModState, "keyboard_getSetModState", "Check call to SDL_GetModState and SDL_SetModState", TEST_ENABLED };
   675 
   676 static const SDLTest_TestCaseReference keyboardTest7 =
   677         { (SDLTest_TestCaseFp)keyboard_startStopTextInput, "keyboard_startStopTextInput", "Check call to SDL_StartTextInput and SDL_StopTextInput", TEST_ENABLED };
   678 
   679 static const SDLTest_TestCaseReference keyboardTest8 =
   680         { (SDLTest_TestCaseFp)keyboard_setTextInputRect, "keyboard_setTextInputRect", "Check call to SDL_SetTextInputRect", TEST_ENABLED };
   681 
   682 static const SDLTest_TestCaseReference keyboardTest9 =
   683         { (SDLTest_TestCaseFp)keyboard_setTextInputRectNegative, "keyboard_setTextInputRectNegative", "Check call to SDL_SetTextInputRect with invalid data", TEST_ENABLED };
   684 
   685 static const SDLTest_TestCaseReference keyboardTest10 =
   686         { (SDLTest_TestCaseFp)keyboard_getScancodeFromKey, "keyboard_getScancodeFromKey", "Check call to SDL_GetScancodeFromKey", TEST_ENABLED };
   687 
   688 static const SDLTest_TestCaseReference keyboardTest11 =
   689         { (SDLTest_TestCaseFp)keyboard_getScancodeFromName, "keyboard_getScancodeFromName", "Check call to SDL_GetScancodeFromName", TEST_ENABLED };
   690 
   691 static const SDLTest_TestCaseReference keyboardTest12 =
   692         { (SDLTest_TestCaseFp)keyboard_getScancodeFromNameNegative, "keyboard_getScancodeFromNameNegative", "Check call to SDL_GetScancodeFromName with invalid data", TEST_ENABLED };
   693 
   694 static const SDLTest_TestCaseReference keyboardTest13 =
   695         { (SDLTest_TestCaseFp)keyboard_getKeyNameNegative, "keyboard_getKeyNameNegative", "Check call to SDL_GetKeyName with invalid data", TEST_ENABLED };
   696 
   697 static const SDLTest_TestCaseReference keyboardTest14 =
   698         { (SDLTest_TestCaseFp)keyboard_getScancodeNameNegative, "keyboard_getScancodeNameNegative", "Check call to SDL_GetScancodeName with invalid data", TEST_ENABLED };
   699 
   700 /* Sequence of Keyboard test cases */
   701 static const SDLTest_TestCaseReference *keyboardTests[] =  {
   702     &keyboardTest1, &keyboardTest2, &keyboardTest3, &keyboardTest4, &keyboardTest5, &keyboardTest6,
   703     &keyboardTest7, &keyboardTest8, &keyboardTest9, &keyboardTest10, &keyboardTest11, &keyboardTest12,
   704     &keyboardTest13, &keyboardTest14, NULL
   705 };
   706 
   707 /* Keyboard test suite (global) */
   708 SDLTest_TestSuiteReference keyboardTestSuite = {
   709     "Keyboard",
   710     NULL,
   711     keyboardTests,
   712     NULL
   713 };