From 6aaedb813fa11ba0679c3051bc2eb28646b9506c Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 30 Aug 2025 16:53:58 -0700 Subject: Update to SDL3 --- src/contrib/SDL-3.2.20/test/testautomation_mouse.c | 689 +++++++++++++++++++++ 1 file changed, 689 insertions(+) create mode 100644 src/contrib/SDL-3.2.20/test/testautomation_mouse.c (limited to 'src/contrib/SDL-3.2.20/test/testautomation_mouse.c') diff --git a/src/contrib/SDL-3.2.20/test/testautomation_mouse.c b/src/contrib/SDL-3.2.20/test/testautomation_mouse.c new file mode 100644 index 0000000..9efa630 --- /dev/null +++ b/src/contrib/SDL-3.2.20/test/testautomation_mouse.c @@ -0,0 +1,689 @@ +/** + * Mouse test suite + */ +#include +#include + +#include +#include +#include "testautomation_suites.h" +#include "testautomation_images.h" + +/* ================= Test Case Implementation ================== */ + +/* Test case functions */ + +/* Helper to evaluate state returned from SDL_GetMouseState */ +static int mouseStateCheck(Uint32 state) +{ + return (state == 0) || + (state == SDL_BUTTON_MASK(SDL_BUTTON_LEFT)) || + (state == SDL_BUTTON_MASK(SDL_BUTTON_MIDDLE)) || + (state == SDL_BUTTON_MASK(SDL_BUTTON_RIGHT)) || + (state == SDL_BUTTON_MASK(SDL_BUTTON_X1)) || + (state == SDL_BUTTON_MASK(SDL_BUTTON_X2)); +} + +/** + * Check call to SDL_GetMouseState + * + */ +static int SDLCALL mouse_getMouseState(void *arg) +{ + float x; + float y; + SDL_MouseButtonFlags state; + + /* Pump some events to update mouse state */ + SDL_PumpEvents(); + SDLTest_AssertPass("Call to SDL_PumpEvents()"); + + /* Case where x, y pointer is NULL */ + state = SDL_GetMouseState(NULL, NULL); + SDLTest_AssertPass("Call to SDL_GetMouseState(NULL, NULL)"); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + /* Case where x pointer is not NULL */ + x = -FLT_MAX; + state = SDL_GetMouseState(&x, NULL); + SDLTest_AssertPass("Call to SDL_GetMouseState(&x, NULL)"); + SDLTest_AssertCheck(x > -FLT_MAX, "Validate that value of x is > -FLT_MAX, got: %g", x); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + /* Case where y pointer is not NULL */ + y = -FLT_MAX; + state = SDL_GetMouseState(NULL, &y); + SDLTest_AssertPass("Call to SDL_GetMouseState(NULL, &y)"); + SDLTest_AssertCheck(y > -FLT_MAX, "Validate that value of y is > -FLT_MAX, got: %g", y); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + /* Case where x and y pointer is not NULL */ + x = -FLT_MAX; + y = -FLT_MAX; + state = SDL_GetMouseState(&x, &y); + SDLTest_AssertPass("Call to SDL_GetMouseState(&x, &y)"); + SDLTest_AssertCheck(x > -FLT_MAX, "Validate that value of x is > -FLT_MAX, got: %g", x); + SDLTest_AssertCheck(y > -FLT_MAX, "Validate that value of y is > -FLT_MAX, got: %g", y); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + return TEST_COMPLETED; +} + +/** + * Check call to SDL_GetRelativeMouseState + * + */ +static int SDLCALL mouse_getRelativeMouseState(void *arg) +{ + float x; + float y; + SDL_MouseButtonFlags state; + + /* Pump some events to update mouse state */ + SDL_PumpEvents(); + SDLTest_AssertPass("Call to SDL_PumpEvents()"); + + /* Case where x, y pointer is NULL */ + state = SDL_GetRelativeMouseState(NULL, NULL); + SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(NULL, NULL)"); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + /* Case where x pointer is not NULL */ + x = -FLT_MAX; + state = SDL_GetRelativeMouseState(&x, NULL); + SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(&x, NULL)"); + SDLTest_AssertCheck(x > -FLT_MAX, "Validate that value of x is > -FLT_MAX, got: %g", x); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + /* Case where y pointer is not NULL */ + y = -FLT_MAX; + state = SDL_GetRelativeMouseState(NULL, &y); + SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(NULL, &y)"); + SDLTest_AssertCheck(y > -FLT_MAX, "Validate that value of y is > -FLT_MAX, got: %g", y); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + /* Case where x and y pointer is not NULL */ + x = -FLT_MAX; + y = -FLT_MAX; + state = SDL_GetRelativeMouseState(&x, &y); + SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(&x, &y)"); + SDLTest_AssertCheck(x > -FLT_MAX, "Validate that value of x is > -FLT_MAX, got: %g", x); + SDLTest_AssertCheck(y > -FLT_MAX, "Validate that value of y is > -FLT_MAX, got: %g", y); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + return TEST_COMPLETED; +} + +/* XPM definition of mouse Cursor */ +static const char *g_mouseArrowData[] = { + /* pixels */ + "X ", + "XX ", + "X.X ", + "X..X ", + "X...X ", + "X....X ", + "X.....X ", + "X......X ", + "X.......X ", + "X........X ", + "X.....XXXXX ", + "X..X..X ", + "X.X X..X ", + "XX X..X ", + "X X..X ", + " X..X ", + " X..X ", + " X..X ", + " XX ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " " +}; + +/* Helper that creates a new mouse cursor from an XPM */ +static SDL_Cursor *initArrowCursor(const char *image[]) +{ + SDL_Cursor *cursor; + int i, row, col; + Uint8 data[4 * 32]; + Uint8 mask[4 * 32]; + + i = -1; + for (row = 0; row < 32; ++row) { + for (col = 0; col < 32; ++col) { + if (col % 8) { + data[i] <<= 1; + mask[i] <<= 1; + } else { + ++i; + data[i] = mask[i] = 0; + } + switch (image[row][col]) { + case 'X': + data[i] |= 0x01; + mask[i] |= 0x01; + break; + case '.': + mask[i] |= 0x01; + break; + case ' ': + break; + } + } + } + + cursor = SDL_CreateCursor(data, mask, 32, 32, 0, 0); + return cursor; +} + +/** + * Check call to SDL_CreateCursor and SDL_DestroyCursor + * + * \sa SDL_CreateCursor + * \sa SDL_DestroyCursor + */ +static int SDLCALL mouse_createFreeCursor(void *arg) +{ + SDL_Cursor *cursor; + + /* Create a cursor */ + cursor = initArrowCursor(g_mouseArrowData); + SDLTest_AssertPass("Call to SDL_CreateCursor()"); + SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateCursor() is not NULL"); + if (cursor == NULL) { + return TEST_ABORTED; + } + + /* Free cursor again */ + SDLTest_AssertPass("About to call SDL_DestroyCursor()"); + SDL_DestroyCursor(cursor); + SDLTest_AssertPass("Call to SDL_DestroyCursor()"); + + return TEST_COMPLETED; +} + +/** + * Check call to SDL_CreateColorCursor and SDL_DestroyCursor + * + * \sa SDL_CreateColorCursor + * \sa SDL_DestroyCursor + */ +static int SDLCALL mouse_createFreeColorCursor(void *arg) +{ + SDL_Surface *face; + SDL_Cursor *cursor; + + /* Get sample surface */ + face = SDLTest_ImageFace(); + SDLTest_AssertCheck(face != NULL, "Validate sample input image is not NULL"); + if (face == NULL) { + return TEST_ABORTED; + } + + /* Create a color cursor from surface */ + cursor = SDL_CreateColorCursor(face, 0, 0); + SDLTest_AssertPass("Call to SDL_CreateColorCursor()"); + SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateColorCursor() is not NULL"); + if (cursor == NULL) { + SDL_DestroySurface(face); + return TEST_ABORTED; + } + + /* Free cursor again */ + SDLTest_AssertPass("About to call SDL_DestroyCursor()"); + SDL_DestroyCursor(cursor); + SDLTest_AssertPass("Call to SDL_DestroyCursor()"); + + /* Clean up */ + SDL_DestroySurface(face); + + return TEST_COMPLETED; +} + +/* Helper that changes cursor visibility */ +static void changeCursorVisibility(bool state) +{ + bool newState; + + if (state) { + SDL_ShowCursor(); + } else { + SDL_HideCursor(); + } + SDLTest_AssertPass("Call to %s", state ? "SDL_ShowCursor()" : "SDL_HideCursor()"); + + newState = SDL_CursorVisible(); + SDLTest_AssertPass("Call to SDL_CursorVisible()"); + SDLTest_AssertCheck(state == newState, "Validate new state, expected: %s, got: %s", + state ? "true" : "false", + newState ? "true" : "false"); +} + +/** + * Check call to SDL_ShowCursor + * + * \sa SDL_ShowCursor + */ +static int SDLCALL mouse_showCursor(void *arg) +{ + bool currentState; + + /* Get current state */ + currentState = SDL_CursorVisible(); + SDLTest_AssertPass("Call to SDL_CursorVisible()"); + if (currentState) { + /* Hide the cursor, then show it again */ + changeCursorVisibility(false); + changeCursorVisibility(true); + } else { + /* Show the cursor, then hide it again */ + changeCursorVisibility(true); + changeCursorVisibility(false); + } + + return TEST_COMPLETED; +} + +/** + * Check call to SDL_SetCursor + * + * \sa SDL_SetCursor + */ +static int SDLCALL mouse_setCursor(void *arg) +{ + SDL_Cursor *cursor; + + /* Create a cursor */ + cursor = initArrowCursor(g_mouseArrowData); + SDLTest_AssertPass("Call to SDL_CreateCursor()"); + SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateCursor() is not NULL"); + if (cursor == NULL) { + return TEST_ABORTED; + } + + /* Set the arrow cursor */ + SDL_SetCursor(cursor); + SDLTest_AssertPass("Call to SDL_SetCursor(cursor)"); + + /* Force redraw */ + SDL_SetCursor(NULL); + SDLTest_AssertPass("Call to SDL_SetCursor(NULL)"); + + /* Free cursor again */ + SDLTest_AssertPass("About to call SDL_DestroyCursor()"); + SDL_DestroyCursor(cursor); + SDLTest_AssertPass("Call to SDL_DestroyCursor()"); + + return TEST_COMPLETED; +} + +/** + * Check call to SDL_GetCursor + * + * \sa SDL_GetCursor + */ +static int SDLCALL mouse_getCursor(void *arg) +{ + SDL_Cursor *cursor; + + /* Get current cursor */ + cursor = SDL_GetCursor(); + SDLTest_AssertPass("Call to SDL_GetCursor()"); + SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_GetCursor() is not NULL"); + + return TEST_COMPLETED; +} + +#define MOUSE_TESTWINDOW_WIDTH 320 +#define MOUSE_TESTWINDOW_HEIGHT 200 + +/** + * Creates a test window + */ +static SDL_Window *createMouseSuiteTestWindow(void) +{ + int width = MOUSE_TESTWINDOW_WIDTH, height = MOUSE_TESTWINDOW_HEIGHT; + SDL_Window *window; + window = SDL_CreateWindow("mousecreateMouseSuiteTestWindow", width, height, 0); + SDLTest_AssertPass("SDL_CreateWindow()"); + SDLTest_AssertCheck(window != NULL, "Check SDL_CreateWindow result"); + return window; +} + +/** + * Destroy test window + */ +static void destroyMouseSuiteTestWindow(SDL_Window *window) +{ + if (window) { + SDL_DestroyWindow(window); + window = NULL; + SDLTest_AssertPass("SDL_DestroyWindow()"); + } +} + +/** + * Check call to SDL_GetWindowRelativeMouseMode and SDL_SetWindowRelativeMouseMode + * + * \sa SDL_GetWindowRelativeMouseMode + * \sa SDL_SetWindowRelativeMouseMode + */ +static int SDLCALL mouse_getSetRelativeMouseMode(void *arg) +{ + SDL_Window *window; + int result; + int i; + bool initialState; + bool currentState; + + /* Create test window */ + window = createMouseSuiteTestWindow(); + if (!window) { + return TEST_ABORTED; + } + + /* Capture original state so we can revert back to it later */ + initialState = SDL_GetWindowRelativeMouseMode(window); + SDLTest_AssertPass("Call to SDL_GetWindowRelativeMouseMode(window)"); + + /* Repeat twice to check D->D transition */ + for (i = 0; i < 2; i++) { + /* Disable - should always be supported */ + result = SDL_SetWindowRelativeMouseMode(window, false); + SDLTest_AssertPass("Call to SDL_SetWindowRelativeMouseMode(window, FALSE)"); + SDLTest_AssertCheck(result == true, "Validate result value from SDL_SetWindowRelativeMouseMode, expected: true, got: %i", result); + currentState = SDL_GetWindowRelativeMouseMode(window); + SDLTest_AssertPass("Call to SDL_GetWindowRelativeMouseMode(window)"); + SDLTest_AssertCheck(currentState == false, "Validate current state is FALSE, got: %i", currentState); + } + + /* Repeat twice to check D->E->E transition */ + for (i = 0; i < 2; i++) { + /* Enable - may not be supported */ + result = SDL_SetWindowRelativeMouseMode(window, true); + SDLTest_AssertPass("Call to SDL_SetWindowRelativeMouseMode(window, TRUE)"); + if (result != -1) { + SDLTest_AssertCheck(result == true, "Validate result value from SDL_SetWindowRelativeMouseMode, expected: true, got: %i", result); + currentState = SDL_GetWindowRelativeMouseMode(window); + SDLTest_AssertPass("Call to SDL_GetWindowRelativeMouseMode(window)"); + SDLTest_AssertCheck(currentState == true, "Validate current state is TRUE, got: %i", currentState); + } + } + + /* Disable to check E->D transition */ + result = SDL_SetWindowRelativeMouseMode(window, false); + SDLTest_AssertPass("Call to SDL_SetWindowRelativeMouseMode(window, FALSE)"); + SDLTest_AssertCheck(result == true, "Validate result value from SDL_SetWindowRelativeMouseMode, expected: true, got: %i", result); + currentState = SDL_GetWindowRelativeMouseMode(window); + SDLTest_AssertPass("Call to SDL_GetWindowRelativeMouseMode(window)"); + SDLTest_AssertCheck(currentState == false, "Validate current state is FALSE, got: %i", currentState); + + /* Revert to original state - ignore result */ + result = SDL_SetWindowRelativeMouseMode(window, initialState); + + /* Clean up test window */ + destroyMouseSuiteTestWindow(window); + + return TEST_COMPLETED; +} + +/** + * Check call to SDL_WarpMouseInWindow + * + * \sa SDL_WarpMouseInWindow + */ +static int SDLCALL mouse_warpMouseInWindow(void *arg) +{ + const int w = MOUSE_TESTWINDOW_WIDTH, h = MOUSE_TESTWINDOW_HEIGHT; + int numPositions = 6; + float xPositions[6]; + float yPositions[6]; + float x, y; + int i, j; + SDL_Window *window; + + xPositions[0] = -1; + xPositions[1] = 0; + xPositions[2] = 1; + xPositions[3] = (float)w - 1; + xPositions[4] = (float)w; + xPositions[5] = (float)w + 1; + yPositions[0] = -1; + yPositions[1] = 0; + yPositions[2] = 1; + yPositions[3] = (float)h - 1; + yPositions[4] = (float)h; + yPositions[5] = (float)h + 1; + /* Create test window */ + window = createMouseSuiteTestWindow(); + if (!window) { + return TEST_ABORTED; + } + + /* Mouse to random position inside window */ + x = (float)SDLTest_RandomIntegerInRange(1, w - 1); + y = (float)SDLTest_RandomIntegerInRange(1, h - 1); + SDL_WarpMouseInWindow(window, x, y); + SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%.f,%.f)", x, y); + + /* Same position again */ + SDL_WarpMouseInWindow(window, x, y); + SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%.f,%.f)", x, y); + + /* Mouse to various boundary positions */ + for (i = 0; i < numPositions; i++) { + for (j = 0; j < numPositions; j++) { + x = xPositions[i]; + y = yPositions[j]; + SDL_WarpMouseInWindow(window, x, y); + SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%.f,%.f)", x, y); + + /* TODO: add tracking of events and check that each call generates a mouse motion event */ + SDL_PumpEvents(); + SDLTest_AssertPass("SDL_PumpEvents()"); + } + } + + /* Clean up test window */ + destroyMouseSuiteTestWindow(window); + + return TEST_COMPLETED; +} + +/** + * Check call to SDL_GetMouseFocus + * + * \sa SDL_GetMouseFocus + */ +static int SDLCALL mouse_getMouseFocus(void *arg) +{ + const int w = MOUSE_TESTWINDOW_WIDTH, h = MOUSE_TESTWINDOW_HEIGHT; + float x, y; + SDL_Window *window; + SDL_Window *focusWindow; + const char *xdg_session = SDL_getenv("XDG_SESSION_TYPE"); + const bool env_is_wayland = !SDL_strcmp(xdg_session ? xdg_session : "", "wayland"); + + /* Get focus - focus non-deterministic */ + focusWindow = SDL_GetMouseFocus(); + SDLTest_AssertPass("SDL_GetMouseFocus()"); + + /* Create test window */ + window = createMouseSuiteTestWindow(); + if (!window) { + return TEST_ABORTED; + } + + /* Delay a brief period to allow the window to actually appear on the desktop. */ + SDL_Delay(100); + + /* Warping the pointer when it is outside the window on a Wayland desktop usually doesn't work, so this test will be skipped. */ + if (!env_is_wayland) { + /* Mouse to random position inside window */ + x = (float)SDLTest_RandomIntegerInRange(1, w - 1); + y = (float)SDLTest_RandomIntegerInRange(1, h - 1); + SDL_WarpMouseInWindow(window, x, y); + SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%.f,%.f)", x, y); + + /* Pump events to update focus state */ + SDL_Delay(100); + SDL_PumpEvents(); + SDLTest_AssertPass("SDL_PumpEvents()"); + + /* Get focus with explicit window setup - focus deterministic */ + focusWindow = SDL_GetMouseFocus(); + SDLTest_AssertPass("SDL_GetMouseFocus()"); + SDLTest_AssertCheck(focusWindow != NULL, "Check returned window value is not NULL"); + SDLTest_AssertCheck(focusWindow == window, "Check returned window value is test window"); + + /* Mouse to random position outside window */ + x = (float)SDLTest_RandomIntegerInRange(-9, -1); + y = (float)SDLTest_RandomIntegerInRange(-9, -1); + SDL_WarpMouseInWindow(window, x, y); + SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%.f,%.f)", x, y); + } else { + SDLTest_Log("Skipping mouse warp focus tests: warping the mouse pointer when outside the window is unreliable on Wayland/XWayland"); + } + + /* Clean up test window */ + destroyMouseSuiteTestWindow(window); + + /* Pump events to update focus state */ + SDL_PumpEvents(); + SDLTest_AssertPass("SDL_PumpEvents()"); + + /* Get focus for non-existing window */ + focusWindow = SDL_GetMouseFocus(); + SDLTest_AssertPass("SDL_GetMouseFocus()"); + SDLTest_AssertCheck(focusWindow == NULL, "Check returned window value is NULL"); + + return TEST_COMPLETED; +} + +/** + * Check call to SDL_GetDefaultCursor + * + * \sa SDL_GetDefaultCursor + */ +static int SDLCALL mouse_getDefaultCursor(void *arg) +{ + SDL_Cursor *cursor; + + /* Get current cursor */ + cursor = SDL_GetDefaultCursor(); + SDLTest_AssertPass("Call to SDL_GetDefaultCursor()"); + SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_GetDefaultCursor() is not NULL"); + + return TEST_COMPLETED; +} + +/** + * Check call to SDL_GetGlobalMouseState + * + * \sa SDL_GetGlobalMouseState + */ +static int SDLCALL mouse_getGlobalMouseState(void *arg) +{ + float x; + float y; + SDL_MouseButtonFlags state; + + x = -FLT_MAX; + y = -FLT_MAX; + + /* Get current cursor */ + state = SDL_GetGlobalMouseState(&x, &y); + SDLTest_AssertPass("Call to SDL_GetGlobalMouseState()"); + SDLTest_AssertCheck(x > -FLT_MAX, "Validate that value of x is > -FLT_MAX, got: %.f", x); + SDLTest_AssertCheck(y > -FLT_MAX, "Validate that value of y is > -FLT_MAX, got: %.f", y); + SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state); + + return TEST_COMPLETED; +} + +/* ================= Test References ================== */ + +/* Mouse test cases */ +static const SDLTest_TestCaseReference mouseTestGetMouseState = { + mouse_getMouseState, "mouse_getMouseState", "Check call to SDL_GetMouseState", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestGetRelativeMouseState = { + mouse_getRelativeMouseState, "mouse_getRelativeMouseState", "Check call to SDL_GetRelativeMouseState", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestCreateFreeCursor = { + mouse_createFreeCursor, "mouse_createFreeCursor", "Check call to SDL_CreateCursor and SDL_DestroyCursor", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestShowCursor = { + mouse_showCursor, "mouse_showCursor", "Check call to SDL_ShowCursor", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestSetCursor = { + mouse_setCursor, "mouse_setCursor", "Check call to SDL_SetCursor", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestGetCursor = { + mouse_getCursor, "mouse_getCursor", "Check call to SDL_GetCursor", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestWarpMouseInWindow = { + mouse_warpMouseInWindow, "mouse_warpMouseInWindow", "Check call to SDL_WarpMouseInWindow", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestGetMouseFocus = { + mouse_getMouseFocus, "mouse_getMouseFocus", "Check call to SDL_GetMouseFocus", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestCreateFreeColorCursor = { + mouse_createFreeColorCursor, "mouse_createFreeColorCursor", "Check call to SDL_CreateColorCursor and SDL_DestroyCursor", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestGetSetRelativeMouseMode = { + mouse_getSetRelativeMouseMode, "mouse_getSetRelativeMouseMode", "Check call to SDL_GetWindowRelativeMouseMode and SDL_SetWindowRelativeMouseMode", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestGetDefaultCursor = { + mouse_getDefaultCursor, "mouse_getDefaultCursor", "Check call to SDL_GetDefaultCursor", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference mouseTestGetGlobalMouseState = { + mouse_getGlobalMouseState, "mouse_getGlobalMouseState", "Check call to SDL_GetGlobalMouseState", TEST_ENABLED +}; + +/* Sequence of Mouse test cases */ +static const SDLTest_TestCaseReference *mouseTests[] = { + &mouseTestGetMouseState, + &mouseTestGetRelativeMouseState, + &mouseTestCreateFreeCursor, + &mouseTestShowCursor, + &mouseTestSetCursor, + &mouseTestGetCursor, + &mouseTestWarpMouseInWindow, + &mouseTestGetMouseFocus, + &mouseTestCreateFreeColorCursor, + &mouseTestGetSetRelativeMouseMode, + &mouseTestGetDefaultCursor, + &mouseTestGetGlobalMouseState, + NULL +}; + +/* Mouse test suite (global) */ +SDLTest_TestSuiteReference mouseTestSuite = { + "Mouse", + NULL, + mouseTests, + NULL +}; -- cgit v1.2.3