summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/test/testautomation_keyboard.c
diff options
context:
space:
mode:
author Miodrag Milanovic <mmicko@gmail.com>2016-02-27 16:28:05 +0100
committer Miodrag Milanovic <mmicko@gmail.com>2016-02-27 16:53:49 +0100
commitcf6dc7d370407914020f3e623719f09c8668c692 (patch)
tree46b3416d091b4c09b50fba7ffcbd310aed032cc8 /3rdparty/SDL2/test/testautomation_keyboard.c
parent64135e73f973d9b95beb0c60b65feb34fbfec64a (diff)
Placed SDL2 source since we need it on some platforms (nw)
Diffstat (limited to '3rdparty/SDL2/test/testautomation_keyboard.c')
-rw-r--r--3rdparty/SDL2/test/testautomation_keyboard.c713
1 files changed, 713 insertions, 0 deletions
diff --git a/3rdparty/SDL2/test/testautomation_keyboard.c b/3rdparty/SDL2/test/testautomation_keyboard.c
new file mode 100644
index 00000000000..453832e2561
--- /dev/null
+++ b/3rdparty/SDL2/test/testautomation_keyboard.c
@@ -0,0 +1,713 @@
+/**
+ * Keyboard test suite
+ */
+
+#include <stdio.h>
+#include <limits.h>
+
+#include "SDL_config.h"
+#include "SDL.h"
+#include "SDL_test.h"
+
+/* ================= Test Case Implementation ================== */
+
+/* Test case functions */
+
+/**
+ * @brief Check call to SDL_GetKeyboardState with and without numkeys reference.
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyboardState
+ */
+int
+keyboard_getKeyboardState(void *arg)
+{
+ int numkeys;
+ Uint8 *state;
+
+ /* Case where numkeys pointer is NULL */
+ state = (Uint8 *)SDL_GetKeyboardState(NULL);
+ SDLTest_AssertPass("Call to SDL_GetKeyboardState(NULL)");
+ SDLTest_AssertCheck(state != NULL, "Validate that return value from SDL_GetKeyboardState is not NULL");
+
+ /* Case where numkeys pointer is not NULL */
+ numkeys = -1;
+ state = (Uint8 *)SDL_GetKeyboardState(&numkeys);
+ SDLTest_AssertPass("Call to SDL_GetKeyboardState(&numkeys)");
+ SDLTest_AssertCheck(state != NULL, "Validate that return value from SDL_GetKeyboardState is not NULL");
+ SDLTest_AssertCheck(numkeys >= 0, "Validate that value of numkeys is >= 0, got: %i", numkeys);
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief Check call to SDL_GetKeyboardFocus
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyboardFocus
+ */
+int
+keyboard_getKeyboardFocus(void *arg)
+{
+ SDL_Window* window;
+
+ /* Call, but ignore return value */
+ window = SDL_GetKeyboardFocus();
+ SDLTest_AssertPass("Call to SDL_GetKeyboardFocus()");
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief Check call to SDL_GetKeyFromName for known, unknown and invalid name.
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromName
+ */
+int
+keyboard_getKeyFromName(void *arg)
+{
+ SDL_Keycode result;
+
+ /* Case where Key is known, 1 character input */
+ result = SDL_GetKeyFromName("A");
+ SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/single)");
+ SDLTest_AssertCheck(result == SDLK_a, "Verify result from call, expected: %i, got: %i", SDLK_a, result);
+
+ /* Case where Key is known, 2 character input */
+ result = SDL_GetKeyFromName("F1");
+ SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/double)");
+ SDLTest_AssertCheck(result == SDLK_F1, "Verify result from call, expected: %i, got: %i", SDLK_F1, result);
+
+ /* Case where Key is known, 3 character input */
+ result = SDL_GetKeyFromName("End");
+ SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/triple)");
+ SDLTest_AssertCheck(result == SDLK_END, "Verify result from call, expected: %i, got: %i", SDLK_END, result);
+
+ /* Case where Key is known, 4 character input */
+ result = SDL_GetKeyFromName("Find");
+ SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/quad)");
+ SDLTest_AssertCheck(result == SDLK_FIND, "Verify result from call, expected: %i, got: %i", SDLK_FIND, result);
+
+ /* Case where Key is known, multiple character input */
+ result = SDL_GetKeyFromName("AudioStop");
+ SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/multi)");
+ SDLTest_AssertCheck(result == SDLK_AUDIOSTOP, "Verify result from call, expected: %i, got: %i", SDLK_AUDIOSTOP, result);
+
+ /* Case where Key is unknown */
+ result = SDL_GetKeyFromName("NotThere");
+ SDLTest_AssertPass("Call to SDL_GetKeyFromName(unknown)");
+ SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
+
+ /* Case where input is NULL/invalid */
+ result = SDL_GetKeyFromName(NULL);
+ SDLTest_AssertPass("Call to SDL_GetKeyFromName(NULL)");
+ SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
+
+ return TEST_COMPLETED;
+}
+
+/*
+ * Local helper to check for the invalid scancode error message
+ */
+void
+_checkInvalidScancodeError()
+{
+ const char *expectedError = "Parameter 'scancode' is invalid";
+ const char *error;
+ error = SDL_GetError();
+ SDLTest_AssertPass("Call to SDL_GetError()");
+ SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
+ if (error != NULL) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
+ "Validate error message, expected: '%s', got: '%s'", expectedError, error);
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+ }
+}
+
+/**
+ * @brief Check call to SDL_GetKeyFromScancode
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromScancode
+ */
+int
+keyboard_getKeyFromScancode(void *arg)
+{
+ SDL_Keycode result;
+
+ /* Case where input is valid */
+ result = SDL_GetKeyFromScancode(SDL_SCANCODE_A);
+ SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(valid)");
+ SDLTest_AssertCheck(result == SDLK_a, "Verify result from call, expected: %i, got: %i", SDLK_a, result);
+
+ /* Case where input is zero */
+ result = SDL_GetKeyFromScancode(0);
+ SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(0)");
+ SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
+
+ /* Clear error message */
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+
+ /* Case where input is invalid (too small) */
+ result = SDL_GetKeyFromScancode(-999);
+ SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(-999)");
+ SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
+ _checkInvalidScancodeError();
+
+ /* Case where input is invalid (too big) */
+ result = SDL_GetKeyFromScancode(999);
+ SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(999)");
+ SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
+ _checkInvalidScancodeError();
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief Check call to SDL_GetKeyName
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyName
+ */
+int
+keyboard_getKeyName(void *arg)
+{
+ char *result;
+ char *expected;
+
+ /* Case where key has a 1 character name */
+ expected = "3";
+ result = (char *)SDL_GetKeyName(SDLK_3);
+ SDLTest_AssertPass("Call to SDL_GetKeyName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
+
+ /* Case where key has a 2 character name */
+ expected = "F1";
+ result = (char *)SDL_GetKeyName(SDLK_F1);
+ SDLTest_AssertPass("Call to SDL_GetKeyName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
+
+ /* Case where key has a 3 character name */
+ expected = "Cut";
+ result = (char *)SDL_GetKeyName(SDLK_CUT);
+ SDLTest_AssertPass("Call to SDL_GetKeyName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
+
+ /* Case where key has a 4 character name */
+ expected = "Down";
+ result = (char *)SDL_GetKeyName(SDLK_DOWN);
+ SDLTest_AssertPass("Call to SDL_GetKeyName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
+
+ /* Case where key has a N character name */
+ expected = "BrightnessUp";
+ result = (char *)SDL_GetKeyName(SDLK_BRIGHTNESSUP);
+ SDLTest_AssertPass("Call to SDL_GetKeyName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
+
+ /* Case where key has a N character name with space */
+ expected = "Keypad MemStore";
+ result = (char *)SDL_GetKeyName(SDLK_KP_MEMSTORE);
+ SDLTest_AssertPass("Call to SDL_GetKeyName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief SDL_GetScancodeName negative cases
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeName
+ */
+int
+keyboard_getScancodeNameNegative(void *arg)
+{
+ SDL_Scancode scancode;
+ char *result;
+ char *expected = "";
+
+ /* Clear error message */
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+
+ /* Out-of-bounds scancode */
+ scancode = (SDL_Scancode)SDL_NUM_SCANCODES;
+ result = (char *)SDL_GetScancodeName(scancode);
+ SDLTest_AssertPass("Call to SDL_GetScancodeName(%d/large)", scancode);
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result);
+ _checkInvalidScancodeError();
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief SDL_GetKeyName negative cases
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyName
+ */
+int
+keyboard_getKeyNameNegative(void *arg)
+{
+ SDL_Keycode keycode;
+ char *result;
+ char *expected = "";
+
+ /* Unknown keycode */
+ keycode = SDLK_UNKNOWN;
+ result = (char *)SDL_GetKeyName(keycode);
+ SDLTest_AssertPass("Call to SDL_GetKeyName(%d/unknown)", keycode);
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result);
+
+ /* Clear error message */
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+
+ /* Negative keycode */
+ keycode = (SDL_Keycode)SDLTest_RandomIntegerInRange(-255, -1);
+ result = (char *)SDL_GetKeyName(keycode);
+ SDLTest_AssertPass("Call to SDL_GetKeyName(%d/negative)", keycode);
+ SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
+ SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result);
+ _checkInvalidScancodeError();
+
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief Check call to SDL_GetModState and SDL_SetModState
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetModState
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetModState
+ */
+int
+keyboard_getSetModState(void *arg)
+{
+ SDL_Keymod result;
+ SDL_Keymod currentState;
+ SDL_Keymod newState;
+ SDL_Keymod allStates =
+ KMOD_NONE |
+ KMOD_LSHIFT |
+ KMOD_RSHIFT |
+ KMOD_LCTRL |
+ KMOD_RCTRL |
+ KMOD_LALT |
+ KMOD_RALT |
+ KMOD_LGUI |
+ KMOD_RGUI |
+ KMOD_NUM |
+ KMOD_CAPS |
+ KMOD_MODE |
+ KMOD_RESERVED;
+
+ /* Get state, cache for later reset */
+ result = SDL_GetModState();
+ SDLTest_AssertPass("Call to SDL_GetModState()");
+ SDLTest_AssertCheck(result >=0 && result <= allStates, "Verify result from call is valid, expected: 0 <= result <= %i, got: %i", allStates, result);
+ currentState = result;
+
+ /* Set random state */
+ newState = SDLTest_RandomIntegerInRange(0, allStates);
+ SDL_SetModState(newState);
+ SDLTest_AssertPass("Call to SDL_SetModState(%i)", newState);
+ result = SDL_GetModState();
+ SDLTest_AssertPass("Call to SDL_GetModState()");
+ SDLTest_AssertCheck(result == newState, "Verify result from call is valid, expected: %i, got: %i", newState, result);
+
+ /* Set zero state */
+ SDL_SetModState(0);
+ SDLTest_AssertPass("Call to SDL_SetModState(0)");
+ result = SDL_GetModState();
+ SDLTest_AssertPass("Call to SDL_GetModState()");
+ SDLTest_AssertCheck(result == 0, "Verify result from call is valid, expected: 0, got: %i", result);
+
+ /* Revert back to cached current state if needed */
+ if (currentState != 0) {
+ SDL_SetModState(currentState);
+ SDLTest_AssertPass("Call to SDL_SetModState(%i)", currentState);
+ result = SDL_GetModState();
+ SDLTest_AssertPass("Call to SDL_GetModState()");
+ SDLTest_AssertCheck(result == currentState, "Verify result from call is valid, expected: %i, got: %i", currentState, result);
+ }
+
+ return TEST_COMPLETED;
+}
+
+
+/**
+ * @brief Check call to SDL_StartTextInput and SDL_StopTextInput
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_StartTextInput
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_StopTextInput
+ */
+int
+keyboard_startStopTextInput(void *arg)
+{
+ /* Start-Stop */
+ SDL_StartTextInput();
+ SDLTest_AssertPass("Call to SDL_StartTextInput()");
+ SDL_StopTextInput();
+ SDLTest_AssertPass("Call to SDL_StopTextInput()");
+
+ /* Stop-Start */
+ SDL_StartTextInput();
+ SDLTest_AssertPass("Call to SDL_StartTextInput()");
+
+ /* Start-Start */
+ SDL_StartTextInput();
+ SDLTest_AssertPass("Call to SDL_StartTextInput()");
+
+ /* Stop-Stop */
+ SDL_StopTextInput();
+ SDLTest_AssertPass("Call to SDL_StopTextInput()");
+ SDL_StopTextInput();
+ SDLTest_AssertPass("Call to SDL_StopTextInput()");
+
+ return TEST_COMPLETED;
+}
+
+/* Internal function to test SDL_SetTextInputRect */
+void _testSetTextInputRect(SDL_Rect refRect)
+{
+ SDL_Rect testRect;
+
+ testRect = refRect;
+ SDL_SetTextInputRect(&testRect);
+ SDLTest_AssertPass("Call to SDL_SetTextInputRect with refRect(x:%i,y:%i,w:%i,h:%i)", refRect.x, refRect.y, refRect.w, refRect.h);
+ SDLTest_AssertCheck(
+ (refRect.x == testRect.x) && (refRect.y == testRect.y) && (refRect.w == testRect.w) && (refRect.h == testRect.h),
+ "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",
+ refRect.x, refRect.y, refRect.w, refRect.h,
+ testRect.x, testRect.y, testRect.w, testRect.h);
+}
+
+/**
+ * @brief Check call to SDL_SetTextInputRect
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetTextInputRect
+ */
+int
+keyboard_setTextInputRect(void *arg)
+{
+ SDL_Rect refRect;
+
+ /* Normal visible refRect, origin inside */
+ refRect.x = SDLTest_RandomIntegerInRange(1, 50);;
+ refRect.y = SDLTest_RandomIntegerInRange(1, 50);;
+ refRect.w = SDLTest_RandomIntegerInRange(10, 50);
+ refRect.h = SDLTest_RandomIntegerInRange(10, 50);
+ _testSetTextInputRect(refRect);
+
+ /* Normal visible refRect, origin 0,0 */
+ refRect.x = 0;
+ refRect.y = 0;
+ refRect.w = SDLTest_RandomIntegerInRange(10, 50);
+ refRect.h = SDLTest_RandomIntegerInRange(10, 50);
+ _testSetTextInputRect(refRect);
+
+ /* 1Pixel refRect */
+ refRect.x = SDLTest_RandomIntegerInRange(10, 50);;
+ refRect.y = SDLTest_RandomIntegerInRange(10, 50);;
+ refRect.w = 1;
+ refRect.h = 1;
+ _testSetTextInputRect(refRect);
+
+ /* 0pixel refRect */
+ refRect.x = 1;
+ refRect.y = 1;
+ refRect.w = 1;
+ refRect.h = 0;
+ _testSetTextInputRect(refRect);
+
+ /* 0pixel refRect */
+ refRect.x = 1;
+ refRect.y = 1;
+ refRect.w = 0;
+ refRect.h = 1;
+ _testSetTextInputRect(refRect);
+
+ /* 0pixel refRect */
+ refRect.x = 1;
+ refRect.y = 1;
+ refRect.w = 0;
+ refRect.h = 0;
+ _testSetTextInputRect(refRect);
+
+ /* 0pixel refRect */
+ refRect.x = 0;
+ refRect.y = 0;
+ refRect.w = 0;
+ refRect.h = 0;
+ _testSetTextInputRect(refRect);
+
+ /* negative refRect */
+ refRect.x = SDLTest_RandomIntegerInRange(-200, -100);;
+ refRect.y = SDLTest_RandomIntegerInRange(-200, -100);;
+ refRect.w = 50;
+ refRect.h = 50;
+ _testSetTextInputRect(refRect);
+
+ /* oversized refRect */
+ refRect.x = SDLTest_RandomIntegerInRange(1, 50);;
+ refRect.y = SDLTest_RandomIntegerInRange(1, 50);;
+ refRect.w = 5000;
+ refRect.h = 5000;
+ _testSetTextInputRect(refRect);
+
+ /* NULL refRect */
+ SDL_SetTextInputRect(NULL);
+ SDLTest_AssertPass("Call to SDL_SetTextInputRect(NULL)");
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief Check call to SDL_SetTextInputRect with invalid data
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetTextInputRect
+ */
+int
+keyboard_setTextInputRectNegative(void *arg)
+{
+ /* Some platforms set also an error message; prepare for checking it */
+#if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_ANDROID || SDL_VIDEO_DRIVER_COCOA
+ const char *expectedError = "Parameter 'rect' is invalid";
+ const char *error;
+
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+#endif
+
+ /* NULL refRect */
+ SDL_SetTextInputRect(NULL);
+ SDLTest_AssertPass("Call to SDL_SetTextInputRect(NULL)");
+
+ /* Some platforms set also an error message; so check it */
+#if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_ANDROID || SDL_VIDEO_DRIVER_COCOA
+ error = SDL_GetError();
+ SDLTest_AssertPass("Call to SDL_GetError()");
+ SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
+ if (error != NULL) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
+ "Validate error message, expected: '%s', got: '%s'", expectedError, error);
+ }
+
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+#endif
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief Check call to SDL_GetScancodeFromKey
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromKey
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
+ */
+int
+keyboard_getScancodeFromKey(void *arg)
+{
+ SDL_Scancode scancode;
+
+ /* Regular key */
+ scancode = SDL_GetScancodeFromKey(SDLK_4);
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromKey(SDLK_4)");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_4, "Validate return value from SDL_GetScancodeFromKey, expected: %i, got: %i", SDL_SCANCODE_4, scancode);
+
+ /* Virtual key */
+ scancode = SDL_GetScancodeFromKey(SDLK_PLUS);
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromKey(SDLK_PLUS)");
+ SDLTest_AssertCheck(scancode == 0, "Validate return value from SDL_GetScancodeFromKey, expected: 0, got: %i", scancode);
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @brief Check call to SDL_GetScancodeFromName
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromName
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
+ */
+int
+keyboard_getScancodeFromName(void *arg)
+{
+ SDL_Scancode scancode;
+
+ /* Regular key, 1 character, first name in list */
+ scancode = SDL_GetScancodeFromName("A");
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('A')");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_A, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_A, scancode);
+
+ /* Regular key, 1 character */
+ scancode = SDL_GetScancodeFromName("4");
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('4')");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_4, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_4, scancode);
+
+ /* Regular key, 2 characters */
+ scancode = SDL_GetScancodeFromName("F1");
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('F1')");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_F1, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_F1, scancode);
+
+ /* Regular key, 3 characters */
+ scancode = SDL_GetScancodeFromName("End");
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('End')");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_END, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_END, scancode);
+
+ /* Regular key, 4 characters */
+ scancode = SDL_GetScancodeFromName("Find");
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Find')");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_FIND, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_FIND, scancode);
+
+ /* Regular key, several characters */
+ scancode = SDL_GetScancodeFromName("Backspace");
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Backspace')");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_BACKSPACE, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_BACKSPACE, scancode);
+
+ /* Regular key, several characters with space */
+ scancode = SDL_GetScancodeFromName("Keypad Enter");
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Keypad Enter')");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_KP_ENTER, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_KP_ENTER, scancode);
+
+ /* Regular key, last name in list */
+ scancode = SDL_GetScancodeFromName("Sleep");
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Sleep')");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_SLEEP, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_SLEEP, scancode);
+
+ return TEST_COMPLETED;
+}
+
+/*
+ * Local helper to check for the invalid scancode error message
+ */
+void
+_checkInvalidNameError()
+{
+ const char *expectedError = "Parameter 'name' is invalid";
+ const char *error;
+ error = SDL_GetError();
+ SDLTest_AssertPass("Call to SDL_GetError()");
+ SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
+ if (error != NULL) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
+ "Validate error message, expected: '%s', got: '%s'", expectedError, error);
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+ }
+}
+
+/**
+ * @brief Check call to SDL_GetScancodeFromName with invalid data
+ *
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromName
+ * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
+ */
+int
+keyboard_getScancodeFromNameNegative(void *arg)
+{
+ char *name;
+ SDL_Scancode scancode;
+
+ /* Clear error message */
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+
+ /* Random string input */
+ name = SDLTest_RandomAsciiStringOfSize(32);
+ SDLTest_Assert(name != NULL, "Check that random name is not NULL");
+ if (name == NULL) {
+ return TEST_ABORTED;
+ }
+ scancode = SDL_GetScancodeFromName((const char *)name);
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName('%s')", name);
+ SDL_free(name);
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
+ _checkInvalidNameError();
+
+ /* Zero length string input */
+ name = "";
+ scancode = SDL_GetScancodeFromName((const char *)name);
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName(NULL)");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
+ _checkInvalidNameError();
+
+ /* NULL input */
+ name = NULL;
+ scancode = SDL_GetScancodeFromName((const char *)name);
+ SDLTest_AssertPass("Call to SDL_GetScancodeFromName(NULL)");
+ SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
+ _checkInvalidNameError();
+
+ return TEST_COMPLETED;
+}
+
+
+
+/* ================= Test References ================== */
+
+/* Keyboard test cases */
+static const SDLTest_TestCaseReference keyboardTest1 =
+ { (SDLTest_TestCaseFp)keyboard_getKeyboardState, "keyboard_getKeyboardState", "Check call to SDL_GetKeyboardState with and without numkeys reference", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest2 =
+ { (SDLTest_TestCaseFp)keyboard_getKeyboardFocus, "keyboard_getKeyboardFocus", "Check call to SDL_GetKeyboardFocus", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest3 =
+ { (SDLTest_TestCaseFp)keyboard_getKeyFromName, "keyboard_getKeyFromName", "Check call to SDL_GetKeyFromName for known, unknown and invalid name", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest4 =
+ { (SDLTest_TestCaseFp)keyboard_getKeyFromScancode, "keyboard_getKeyFromScancode", "Check call to SDL_GetKeyFromScancode", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest5 =
+ { (SDLTest_TestCaseFp)keyboard_getKeyName, "keyboard_getKeyName", "Check call to SDL_GetKeyName", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest6 =
+ { (SDLTest_TestCaseFp)keyboard_getSetModState, "keyboard_getSetModState", "Check call to SDL_GetModState and SDL_SetModState", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest7 =
+ { (SDLTest_TestCaseFp)keyboard_startStopTextInput, "keyboard_startStopTextInput", "Check call to SDL_StartTextInput and SDL_StopTextInput", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest8 =
+ { (SDLTest_TestCaseFp)keyboard_setTextInputRect, "keyboard_setTextInputRect", "Check call to SDL_SetTextInputRect", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest9 =
+ { (SDLTest_TestCaseFp)keyboard_setTextInputRectNegative, "keyboard_setTextInputRectNegative", "Check call to SDL_SetTextInputRect with invalid data", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest10 =
+ { (SDLTest_TestCaseFp)keyboard_getScancodeFromKey, "keyboard_getScancodeFromKey", "Check call to SDL_GetScancodeFromKey", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest11 =
+ { (SDLTest_TestCaseFp)keyboard_getScancodeFromName, "keyboard_getScancodeFromName", "Check call to SDL_GetScancodeFromName", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest12 =
+ { (SDLTest_TestCaseFp)keyboard_getScancodeFromNameNegative, "keyboard_getScancodeFromNameNegative", "Check call to SDL_GetScancodeFromName with invalid data", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest13 =
+ { (SDLTest_TestCaseFp)keyboard_getKeyNameNegative, "keyboard_getKeyNameNegative", "Check call to SDL_GetKeyName with invalid data", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference keyboardTest14 =
+ { (SDLTest_TestCaseFp)keyboard_getScancodeNameNegative, "keyboard_getScancodeNameNegative", "Check call to SDL_GetScancodeName with invalid data", TEST_ENABLED };
+
+/* Sequence of Keyboard test cases */
+static const SDLTest_TestCaseReference *keyboardTests[] = {
+ &keyboardTest1, &keyboardTest2, &keyboardTest3, &keyboardTest4, &keyboardTest5, &keyboardTest6,
+ &keyboardTest7, &keyboardTest8, &keyboardTest9, &keyboardTest10, &keyboardTest11, &keyboardTest12,
+ &keyboardTest13, &keyboardTest14, NULL
+};
+
+/* Keyboard test suite (global) */
+SDLTest_TestSuiteReference keyboardTestSuite = {
+ "Keyboard",
+ NULL,
+ keyboardTests,
+ NULL
+};