mirror of
https://github.com/libsdl-org/SDL.git
synced 2024-11-23 02:43:30 +08:00
40ff6a2785
X11 seems to need a slight delay before warping the pointer to ensure that the window is actually fully visible on the desktop, or the pointer enter event may not be sent. This also disables the warp focus test on XWayland, as warping the mouse cursor when outside the window on any Wayland desktop usually just doesn't work.
690 lines
22 KiB
C
690 lines
22 KiB
C
/**
|
|
* Mouse test suite
|
|
*/
|
|
#include <limits.h>
|
|
#include <float.h>
|
|
|
|
#include <SDL3/SDL.h>
|
|
#include <SDL3/SDL_test.h>
|
|
#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
|
|
};
|