mirror of https://github.com/libsdl-org/SDL
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
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
|
|
};
|