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.
2532 lines
105 KiB
C
2532 lines
105 KiB
C
/**
|
|
* Video test suite
|
|
*/
|
|
#include <SDL3/SDL.h>
|
|
#include <SDL3/SDL_test.h>
|
|
#include "testautomation_suites.h"
|
|
|
|
/* Private helpers */
|
|
|
|
/**
|
|
* Create a test window
|
|
*/
|
|
static SDL_Window *createVideoSuiteTestWindow(const char *title)
|
|
{
|
|
SDL_Window *window;
|
|
SDL_Window **windows;
|
|
SDL_Event event;
|
|
int w, h;
|
|
int count;
|
|
SDL_WindowFlags flags;
|
|
bool needs_renderer = false;
|
|
bool needs_events_pumped = false;
|
|
|
|
/* Standard window */
|
|
w = SDLTest_RandomIntegerInRange(320, 1024);
|
|
h = SDLTest_RandomIntegerInRange(320, 768);
|
|
flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS;
|
|
|
|
window = SDL_CreateWindow(title, w, h, flags);
|
|
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%" SDL_PRIu64 ")", w, h, flags);
|
|
SDLTest_AssertCheck(window != NULL, "Validate that returned window is not NULL");
|
|
|
|
/* Check the window is available in the window list */
|
|
windows = SDL_GetWindows(&count);
|
|
SDLTest_AssertCheck(windows != NULL, "Validate that returned window list is not NULL");
|
|
SDLTest_AssertCheck(windows[0] == window, "Validate that the window is first in the window list");
|
|
SDL_free(windows);
|
|
|
|
/* Wayland and XWayland windows require that a frame be presented before they are fully mapped and visible onscreen.
|
|
* This is required for the mouse/keyboard grab tests to pass.
|
|
*/
|
|
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "wayland") == 0) {
|
|
needs_renderer = true;
|
|
} else if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0) {
|
|
/* Try to detect if the x11 driver is running under XWayland */
|
|
const char *session_type = SDL_GetEnvironmentVariable(SDL_GetEnvironment(), "XDG_SESSION_TYPE");
|
|
if (session_type && SDL_strcasecmp(session_type, "wayland") == 0) {
|
|
needs_renderer = true;
|
|
}
|
|
|
|
/* X11 needs the initial events pumped, or it can erroneously deliver old configuration events at a later time. */
|
|
needs_events_pumped = true;
|
|
}
|
|
|
|
if (needs_renderer) {
|
|
SDL_Renderer *renderer = SDL_CreateRenderer(window, NULL);
|
|
if (renderer) {
|
|
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
|
|
SDL_RenderClear(renderer);
|
|
SDL_RenderPresent(renderer);
|
|
|
|
/* Some desktops don't display the window immediately after presentation,
|
|
* so delay to give the window time to actually appear on the desktop.
|
|
*/
|
|
SDL_Delay(100);
|
|
} else {
|
|
SDLTest_Log("Unable to create a renderer, some tests may fail on Wayland/XWayland");
|
|
}
|
|
}
|
|
|
|
if (needs_events_pumped) {
|
|
/* Pump out the event queue */
|
|
while (SDL_PollEvent(&event)) {
|
|
}
|
|
}
|
|
|
|
return window;
|
|
}
|
|
|
|
/**
|
|
* Destroy test window
|
|
*/
|
|
static void destroyVideoSuiteTestWindow(SDL_Window *window)
|
|
{
|
|
if (window != NULL) {
|
|
SDL_Renderer *renderer = SDL_GetRenderer(window);
|
|
if (renderer) {
|
|
SDL_DestroyRenderer(renderer);
|
|
}
|
|
SDL_DestroyWindow(window);
|
|
window = NULL;
|
|
SDLTest_AssertPass("Call to SDL_DestroyWindow()");
|
|
}
|
|
}
|
|
|
|
/* Test case functions */
|
|
|
|
/**
|
|
* Enable and disable screensaver while checking state
|
|
*/
|
|
static int SDLCALL video_enableDisableScreensaver(void *arg)
|
|
{
|
|
bool initialResult;
|
|
bool result;
|
|
|
|
/* Get current state and proceed according to current state */
|
|
initialResult = SDL_ScreenSaverEnabled();
|
|
SDLTest_AssertPass("Call to SDL_ScreenSaverEnabled()");
|
|
if (initialResult == true) {
|
|
|
|
/* Currently enabled: disable first, then enable again */
|
|
|
|
/* Disable screensaver and check */
|
|
SDL_DisableScreenSaver();
|
|
SDLTest_AssertPass("Call to SDL_DisableScreenSaver()");
|
|
result = SDL_ScreenSaverEnabled();
|
|
SDLTest_AssertPass("Call to SDL_ScreenSaverEnabled()");
|
|
SDLTest_AssertCheck(result == false, "Verify result from SDL_ScreenSaverEnabled, expected: %i, got: %i", false, result);
|
|
|
|
/* Enable screensaver and check */
|
|
SDL_EnableScreenSaver();
|
|
SDLTest_AssertPass("Call to SDL_EnableScreenSaver()");
|
|
result = SDL_ScreenSaverEnabled();
|
|
SDLTest_AssertPass("Call to SDL_ScreenSaverEnabled()");
|
|
SDLTest_AssertCheck(result == true, "Verify result from SDL_ScreenSaverEnabled, expected: %i, got: %i", true, result);
|
|
|
|
} else {
|
|
|
|
/* Currently disabled: enable first, then disable again */
|
|
|
|
/* Enable screensaver and check */
|
|
SDL_EnableScreenSaver();
|
|
SDLTest_AssertPass("Call to SDL_EnableScreenSaver()");
|
|
result = SDL_ScreenSaverEnabled();
|
|
SDLTest_AssertPass("Call to SDL_ScreenSaverEnabled()");
|
|
SDLTest_AssertCheck(result == true, "Verify result from SDL_ScreenSaverEnabled, expected: %i, got: %i", true, result);
|
|
|
|
/* Disable screensaver and check */
|
|
SDL_DisableScreenSaver();
|
|
SDLTest_AssertPass("Call to SDL_DisableScreenSaver()");
|
|
result = SDL_ScreenSaverEnabled();
|
|
SDLTest_AssertPass("Call to SDL_ScreenSaverEnabled()");
|
|
SDLTest_AssertCheck(result == false, "Verify result from SDL_ScreenSaverEnabled, expected: %i, got: %i", false, result);
|
|
}
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests the functionality of the SDL_CreateWindow function using different sizes
|
|
*/
|
|
static int SDLCALL video_createWindowVariousSizes(void *arg)
|
|
{
|
|
SDL_Window *window;
|
|
const char *title = "video_createWindowVariousSizes Test Window";
|
|
int w = 0, h = 0;
|
|
int wVariation, hVariation;
|
|
|
|
for (wVariation = 0; wVariation < 3; wVariation++) {
|
|
for (hVariation = 0; hVariation < 3; hVariation++) {
|
|
switch (wVariation) {
|
|
case 0:
|
|
/* Width of 1 */
|
|
w = 1;
|
|
break;
|
|
case 1:
|
|
/* Random "normal" width */
|
|
w = SDLTest_RandomIntegerInRange(320, 1920);
|
|
break;
|
|
case 2:
|
|
/* Random "large" width */
|
|
w = SDLTest_RandomIntegerInRange(2048, 4095);
|
|
break;
|
|
}
|
|
|
|
switch (hVariation) {
|
|
case 0:
|
|
/* Height of 1 */
|
|
h = 1;
|
|
break;
|
|
case 1:
|
|
/* Random "normal" height */
|
|
h = SDLTest_RandomIntegerInRange(320, 1080);
|
|
break;
|
|
case 2:
|
|
/* Random "large" height */
|
|
h = SDLTest_RandomIntegerInRange(2048, 4095);
|
|
break;
|
|
}
|
|
|
|
window = SDL_CreateWindow(title, w, h, 0);
|
|
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,SHOWN)", w, h);
|
|
SDLTest_AssertCheck(window != NULL, "Validate that returned window is not NULL");
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
}
|
|
}
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests the functionality of the SDL_CreateWindow function using different flags
|
|
*/
|
|
static int SDLCALL video_createWindowVariousFlags(void *arg)
|
|
{
|
|
SDL_Window *window;
|
|
const char *title = "video_createWindowVariousFlags Test Window";
|
|
int w, h;
|
|
int fVariation;
|
|
SDL_WindowFlags flags;
|
|
|
|
/* Standard window */
|
|
w = SDLTest_RandomIntegerInRange(320, 1024);
|
|
h = SDLTest_RandomIntegerInRange(320, 768);
|
|
|
|
for (fVariation = 1; fVariation < 14; fVariation++) {
|
|
switch (fVariation) {
|
|
default:
|
|
case 1:
|
|
flags = SDL_WINDOW_FULLSCREEN;
|
|
/* Skip - blanks screen; comment out next line to run test */
|
|
continue;
|
|
break;
|
|
case 2:
|
|
flags = SDL_WINDOW_OPENGL;
|
|
/* Skip - not every video driver supports OpenGL; comment out next line to run test */
|
|
continue;
|
|
break;
|
|
case 3:
|
|
flags = 0;
|
|
break;
|
|
case 4:
|
|
flags = SDL_WINDOW_HIDDEN;
|
|
break;
|
|
case 5:
|
|
flags = SDL_WINDOW_BORDERLESS;
|
|
break;
|
|
case 6:
|
|
flags = SDL_WINDOW_RESIZABLE;
|
|
break;
|
|
case 7:
|
|
flags = SDL_WINDOW_MINIMIZED;
|
|
break;
|
|
case 8:
|
|
flags = SDL_WINDOW_MAXIMIZED;
|
|
break;
|
|
case 9:
|
|
flags = SDL_WINDOW_MOUSE_GRABBED;
|
|
break;
|
|
case 10:
|
|
flags = SDL_WINDOW_INPUT_FOCUS;
|
|
break;
|
|
case 11:
|
|
flags = SDL_WINDOW_MOUSE_FOCUS;
|
|
break;
|
|
case 12:
|
|
flags = SDL_WINDOW_EXTERNAL;
|
|
break;
|
|
case 13:
|
|
flags = SDL_WINDOW_KEYBOARD_GRABBED;
|
|
break;
|
|
}
|
|
|
|
window = SDL_CreateWindow(title, w, h, flags);
|
|
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%" SDL_PRIu64 ")", w, h, flags);
|
|
SDLTest_AssertCheck(window != NULL, "Validate that returned window is not NULL");
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
}
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests the functionality of the SDL_GetWindowFlags function
|
|
*/
|
|
static int SDLCALL video_getWindowFlags(void *arg)
|
|
{
|
|
SDL_Window *window;
|
|
const char *title = "video_getWindowFlags Test Window";
|
|
SDL_WindowFlags flags;
|
|
SDL_WindowFlags actualFlags;
|
|
|
|
/* Reliable flag set always set in test window */
|
|
flags = 0;
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (window != NULL) {
|
|
actualFlags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck((flags & actualFlags) == flags, "Verify returned value has flags %" SDL_PRIu64 " set, got: %" SDL_PRIu64, flags, actualFlags);
|
|
}
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests the functionality of the SDL_GetFullscreenDisplayModes function
|
|
*/
|
|
static int SDLCALL video_getFullscreenDisplayModes(void *arg)
|
|
{
|
|
SDL_DisplayID *displays;
|
|
SDL_DisplayMode **modes;
|
|
int count;
|
|
int i;
|
|
|
|
/* Get number of displays */
|
|
displays = SDL_GetDisplays(NULL);
|
|
if (displays) {
|
|
SDLTest_AssertPass("Call to SDL_GetDisplays()");
|
|
|
|
/* Make call for each display */
|
|
for (i = 0; displays[i]; ++i) {
|
|
modes = SDL_GetFullscreenDisplayModes(displays[i], &count);
|
|
SDLTest_AssertPass("Call to SDL_GetFullscreenDisplayModes(%" SDL_PRIu32 ")", displays[i]);
|
|
SDLTest_AssertCheck(modes != NULL, "Validate returned value from function; expected != NULL; got: %p", modes);
|
|
SDLTest_AssertCheck(count >= 0, "Validate number of modes; expected: >= 0; got: %d", count);
|
|
SDL_free(modes);
|
|
}
|
|
SDL_free(displays);
|
|
}
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests the functionality of the SDL_GetClosestFullscreenDisplayMode function against current resolution
|
|
*/
|
|
static int SDLCALL video_getClosestDisplayModeCurrentResolution(void *arg)
|
|
{
|
|
SDL_DisplayID *displays;
|
|
SDL_DisplayMode **modes;
|
|
SDL_DisplayMode current;
|
|
SDL_DisplayMode closest;
|
|
int i, result, num_modes;
|
|
|
|
/* Get number of displays */
|
|
displays = SDL_GetDisplays(NULL);
|
|
if (displays) {
|
|
SDLTest_AssertPass("Call to SDL_GetDisplays()");
|
|
|
|
/* Make calls for each display */
|
|
for (i = 0; displays[i]; ++i) {
|
|
SDLTest_Log("Testing against display: %" SDL_PRIu32, displays[i]);
|
|
|
|
/* Get first display mode to get a sane resolution; this should always work */
|
|
modes = SDL_GetFullscreenDisplayModes(displays[i], &num_modes);
|
|
SDLTest_AssertPass("Call to SDL_GetDisplayModes()");
|
|
SDLTest_Assert(modes != NULL, "Verify returned value is not NULL");
|
|
if (num_modes > 0) {
|
|
SDL_memcpy(¤t, modes[0], sizeof(current));
|
|
|
|
/* Make call */
|
|
result = SDL_GetClosestFullscreenDisplayMode(displays[i], current.w, current.h, current.refresh_rate, false, &closest);
|
|
SDLTest_AssertPass("Call to SDL_GetClosestFullscreenDisplayMode(target=current)");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
/* Check that one gets the current resolution back again */
|
|
if (result == 0) {
|
|
SDLTest_AssertCheck(closest.w == current.w,
|
|
"Verify returned width matches current width; expected: %d, got: %d",
|
|
current.w, closest.w);
|
|
SDLTest_AssertCheck(closest.h == current.h,
|
|
"Verify returned height matches current height; expected: %d, got: %d",
|
|
current.h, closest.h);
|
|
}
|
|
}
|
|
SDL_free(modes);
|
|
}
|
|
SDL_free(displays);
|
|
}
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests the functionality of the SDL_GetClosestFullscreenDisplayMode function against random resolution
|
|
*/
|
|
static int SDLCALL video_getClosestDisplayModeRandomResolution(void *arg)
|
|
{
|
|
SDL_DisplayID *displays;
|
|
SDL_DisplayMode target;
|
|
SDL_DisplayMode closest;
|
|
int i;
|
|
int variation;
|
|
|
|
/* Get number of displays */
|
|
displays = SDL_GetDisplays(NULL);
|
|
if (displays) {
|
|
SDLTest_AssertPass("Call to SDL_GetDisplays()");
|
|
|
|
/* Make calls for each display */
|
|
for (i = 0; displays[i]; ++i) {
|
|
SDLTest_Log("Testing against display: %" SDL_PRIu32, displays[i]);
|
|
|
|
for (variation = 0; variation < 16; variation++) {
|
|
|
|
/* Set random constraints */
|
|
SDL_zero(target);
|
|
target.w = (variation & 1) ? SDLTest_RandomIntegerInRange(1, 4096) : 0;
|
|
target.h = (variation & 2) ? SDLTest_RandomIntegerInRange(1, 4096) : 0;
|
|
target.refresh_rate = (variation & 8) ? (float)SDLTest_RandomIntegerInRange(25, 120) : 0.0f;
|
|
|
|
/* Make call; may or may not find anything, so don't validate any further */
|
|
SDL_GetClosestFullscreenDisplayMode(displays[i], target.w, target.h, target.refresh_rate, false, &closest);
|
|
SDLTest_AssertPass("Call to SDL_GetClosestFullscreenDisplayMode(target=random/variation%d)", variation);
|
|
}
|
|
}
|
|
SDL_free(displays);
|
|
}
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_GetWindowFullscreenMode
|
|
*
|
|
* \sa SDL_GetWindowFullscreenMode
|
|
*/
|
|
static int SDLCALL video_getWindowDisplayMode(void *arg)
|
|
{
|
|
SDL_Window *window;
|
|
const char *title = "video_getWindowDisplayMode Test Window";
|
|
const SDL_DisplayMode *mode;
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (window != NULL) {
|
|
mode = SDL_GetWindowFullscreenMode(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowFullscreenMode()");
|
|
SDLTest_AssertCheck(mode == NULL, "Validate result value; expected: NULL, got: %p", mode);
|
|
}
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/* Helper function that checks for an 'Invalid window' error */
|
|
static void checkInvalidWindowError(void)
|
|
{
|
|
const char *invalidWindowError = "Invalid window";
|
|
const char *lastError;
|
|
|
|
lastError = SDL_GetError();
|
|
SDLTest_AssertPass("SDL_GetError()");
|
|
SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
|
|
if (lastError != NULL) {
|
|
SDLTest_AssertCheck(SDL_strcmp(lastError, invalidWindowError) == 0,
|
|
"SDL_GetError(): expected message '%s', was message: '%s'",
|
|
invalidWindowError,
|
|
lastError);
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_GetWindowFullscreenMode with invalid input
|
|
*
|
|
* \sa SDL_GetWindowFullscreenMode
|
|
*/
|
|
static int SDLCALL video_getWindowDisplayModeNegative(void *arg)
|
|
{
|
|
const SDL_DisplayMode *mode;
|
|
|
|
/* Call against invalid window */
|
|
mode = SDL_GetWindowFullscreenMode(NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowFullscreenMode(window=NULL)");
|
|
SDLTest_AssertCheck(mode == NULL, "Validate result value; expected: NULL, got: %p", mode);
|
|
checkInvalidWindowError();
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/* Helper for setting and checking the window mouse grab state */
|
|
static void setAndCheckWindowMouseGrabState(SDL_Window *window, bool desiredState)
|
|
{
|
|
bool currentState;
|
|
|
|
/* Set state */
|
|
SDL_SetWindowMouseGrab(window, desiredState);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMouseGrab(%s)", (desiredState == false) ? "false" : "true");
|
|
|
|
/* Get and check state */
|
|
currentState = SDL_GetWindowMouseGrab(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMouseGrab()");
|
|
SDLTest_AssertCheck(
|
|
currentState == desiredState,
|
|
"Validate returned state; expected: %s, got: %s",
|
|
(desiredState == false) ? "false" : "true",
|
|
(currentState == false) ? "false" : "true");
|
|
|
|
if (desiredState) {
|
|
SDLTest_AssertCheck(
|
|
SDL_GetGrabbedWindow() == window,
|
|
"Grabbed window should be to our window");
|
|
SDLTest_AssertCheck(
|
|
SDL_GetWindowFlags(window) & SDL_WINDOW_MOUSE_GRABBED,
|
|
"SDL_WINDOW_MOUSE_GRABBED should be set");
|
|
} else {
|
|
SDLTest_AssertCheck(
|
|
!(SDL_GetWindowFlags(window) & SDL_WINDOW_MOUSE_GRABBED),
|
|
"SDL_WINDOW_MOUSE_GRABBED should be unset");
|
|
}
|
|
}
|
|
|
|
/* Helper for setting and checking the window keyboard grab state */
|
|
static void setAndCheckWindowKeyboardGrabState(SDL_Window *window, bool desiredState)
|
|
{
|
|
bool currentState;
|
|
|
|
/* Set state */
|
|
SDL_SetWindowKeyboardGrab(window, desiredState);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowKeyboardGrab(%s)", (desiredState == false) ? "false" : "true");
|
|
|
|
/* Get and check state */
|
|
currentState = SDL_GetWindowKeyboardGrab(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowKeyboardGrab()");
|
|
SDLTest_AssertCheck(
|
|
currentState == desiredState,
|
|
"Validate returned state; expected: %s, got: %s",
|
|
(desiredState == false) ? "false" : "true",
|
|
(currentState == false) ? "false" : "true");
|
|
|
|
if (desiredState) {
|
|
SDLTest_AssertCheck(
|
|
SDL_GetGrabbedWindow() == window,
|
|
"Grabbed window should be set to our window");
|
|
SDLTest_AssertCheck(
|
|
SDL_GetWindowFlags(window) & SDL_WINDOW_KEYBOARD_GRABBED,
|
|
"SDL_WINDOW_KEYBOARD_GRABBED should be set");
|
|
} else {
|
|
SDLTest_AssertCheck(
|
|
!(SDL_GetWindowFlags(window) & SDL_WINDOW_KEYBOARD_GRABBED),
|
|
"SDL_WINDOW_KEYBOARD_GRABBED should be unset");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests keyboard and mouse grab support
|
|
*
|
|
* \sa SDL_GetWindowMouseGrab
|
|
* \sa SDL_GetWindowKeyboardGrab
|
|
* \sa SDL_SetWindowMouseGrab
|
|
* \sa SDL_SetWindowKeyboardGrab
|
|
*/
|
|
static int SDLCALL video_getSetWindowGrab(void *arg)
|
|
{
|
|
const char *title = "video_getSetWindowGrab Test Window";
|
|
SDL_Window *window;
|
|
bool originalMouseState, originalKeyboardState;
|
|
bool hasFocusGained = false;
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
/* Need to raise the window to have and SDL_EVENT_WINDOW_FOCUS_GAINED,
|
|
* so that the window gets the flags SDL_WINDOW_INPUT_FOCUS,
|
|
* so that it can be "grabbed" */
|
|
SDL_RaiseWindow(window);
|
|
|
|
if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_INPUT_FOCUS)) {
|
|
int count = 0;
|
|
SDL_Event evt;
|
|
SDL_zero(evt);
|
|
while (!hasFocusGained && count++ < 3) {
|
|
while (SDL_PollEvent(&evt)) {
|
|
if (evt.type == SDL_EVENT_WINDOW_FOCUS_GAINED) {
|
|
hasFocusGained = true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
hasFocusGained = true;
|
|
}
|
|
|
|
SDLTest_AssertCheck(hasFocusGained == true, "Expectded window with focus");
|
|
|
|
/* Get state */
|
|
originalMouseState = SDL_GetWindowMouseGrab(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMouseGrab()");
|
|
originalKeyboardState = SDL_GetWindowKeyboardGrab(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowKeyboardGrab()");
|
|
|
|
/* F */
|
|
setAndCheckWindowKeyboardGrabState(window, false);
|
|
setAndCheckWindowMouseGrabState(window, false);
|
|
SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
|
|
"Expected NULL grabbed window");
|
|
|
|
/* F --> F */
|
|
setAndCheckWindowMouseGrabState(window, false);
|
|
setAndCheckWindowKeyboardGrabState(window, false);
|
|
SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
|
|
"Expected NULL grabbed window");
|
|
|
|
/* F --> T */
|
|
setAndCheckWindowMouseGrabState(window, true);
|
|
setAndCheckWindowKeyboardGrabState(window, true);
|
|
|
|
/* T --> T */
|
|
setAndCheckWindowKeyboardGrabState(window, true);
|
|
setAndCheckWindowMouseGrabState(window, true);
|
|
|
|
/* M: T --> F */
|
|
/* K: T --> T */
|
|
setAndCheckWindowKeyboardGrabState(window, true);
|
|
setAndCheckWindowMouseGrabState(window, false);
|
|
|
|
/* M: F --> T */
|
|
/* K: T --> F */
|
|
setAndCheckWindowMouseGrabState(window, true);
|
|
setAndCheckWindowKeyboardGrabState(window, false);
|
|
|
|
/* M: T --> F */
|
|
/* K: F --> F */
|
|
setAndCheckWindowMouseGrabState(window, false);
|
|
setAndCheckWindowKeyboardGrabState(window, false);
|
|
SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
|
|
"Expected NULL grabbed window");
|
|
|
|
/* Negative tests */
|
|
SDL_GetWindowMouseGrab(NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMouseGrab(window=NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_GetWindowKeyboardGrab(NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowKeyboardGrab(window=NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_SetWindowMouseGrab(NULL, false);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMouseGrab(window=NULL,false)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_SetWindowKeyboardGrab(NULL, false);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowKeyboardGrab(window=NULL,false)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_SetWindowMouseGrab(NULL, true);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMouseGrab(window=NULL,true)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_SetWindowKeyboardGrab(NULL, true);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowKeyboardGrab(window=NULL,true)");
|
|
checkInvalidWindowError();
|
|
|
|
/* Restore state */
|
|
setAndCheckWindowMouseGrabState(window, originalMouseState);
|
|
setAndCheckWindowKeyboardGrabState(window, originalKeyboardState);
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_GetWindowID and SDL_GetWindowFromID
|
|
*
|
|
* \sa SDL_GetWindowID
|
|
* \sa SDL_SetWindowFromID
|
|
*/
|
|
static int SDLCALL video_getWindowId(void *arg)
|
|
{
|
|
const char *title = "video_getWindowId Test Window";
|
|
SDL_Window *window;
|
|
SDL_Window *result;
|
|
Uint32 id, randomId;
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
/* Get ID */
|
|
id = SDL_GetWindowID(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowID()");
|
|
|
|
/* Get window from ID */
|
|
result = SDL_GetWindowFromID(id);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowID(%" SDL_PRIu32 ")", id);
|
|
SDLTest_AssertCheck(result == window, "Verify result matches window pointer");
|
|
|
|
/* Get window from random large ID, no result check */
|
|
randomId = SDLTest_RandomIntegerInRange(UINT8_MAX, UINT16_MAX);
|
|
result = SDL_GetWindowFromID(randomId);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowID(%" SDL_PRIu32 "/random_large)", randomId);
|
|
|
|
/* Get window from 0 and Uint32 max ID, no result check */
|
|
result = SDL_GetWindowFromID(0);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowID(0)");
|
|
result = SDL_GetWindowFromID(UINT32_MAX);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowID(UINT32_MAX)");
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
/* Get window from ID for closed window */
|
|
result = SDL_GetWindowFromID(id);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowID(%" SDL_PRIu32 "/closed_window)", id);
|
|
SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
|
|
|
|
/* Negative test */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
id = SDL_GetWindowID(NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowID(window=NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_GetWindowPixelFormat
|
|
*
|
|
* \sa SDL_GetWindowPixelFormat
|
|
*/
|
|
static int SDLCALL video_getWindowPixelFormat(void *arg)
|
|
{
|
|
const char *title = "video_getWindowPixelFormat Test Window";
|
|
SDL_Window *window;
|
|
SDL_PixelFormat format;
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
/* Get format */
|
|
format = SDL_GetWindowPixelFormat(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat()");
|
|
SDLTest_AssertCheck(format != SDL_PIXELFORMAT_UNKNOWN, "Verify that returned format is valid; expected: != SDL_PIXELFORMAT_UNKNOWN, got: SDL_PIXELFORMAT_UNKNOWN");
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
/* Negative test */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
format = SDL_GetWindowPixelFormat(NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat(window=NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
|
|
static bool getPositionFromEvent(int *x, int *y)
|
|
{
|
|
bool ret = false;
|
|
SDL_Event evt;
|
|
SDL_zero(evt);
|
|
while (SDL_PollEvent(&evt)) {
|
|
if (evt.type == SDL_EVENT_WINDOW_MOVED) {
|
|
*x = evt.window.data1;
|
|
*y = evt.window.data2;
|
|
ret = true;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static bool getSizeFromEvent(int *w, int *h)
|
|
{
|
|
bool ret = false;
|
|
SDL_Event evt;
|
|
SDL_zero(evt);
|
|
while (SDL_PollEvent(&evt)) {
|
|
if (evt.type == SDL_EVENT_WINDOW_RESIZED) {
|
|
*w = evt.window.data1;
|
|
*h = evt.window.data2;
|
|
ret = true;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_GetWindowPosition and SDL_SetWindowPosition
|
|
*
|
|
* \sa SDL_GetWindowPosition
|
|
* \sa SDL_SetWindowPosition
|
|
*/
|
|
static int SDLCALL video_getSetWindowPosition(void *arg)
|
|
{
|
|
const char *title = "video_getSetWindowPosition Test Window";
|
|
SDL_Window *window;
|
|
int result;
|
|
int maxxVariation, maxyVariation;
|
|
int xVariation, yVariation;
|
|
int referenceX, referenceY;
|
|
int currentX, currentY;
|
|
int desiredX, desiredY;
|
|
SDL_Rect display_bounds;
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
/* Sanity check */
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
if (!SDL_SetWindowPosition(window, currentX, currentY)) {
|
|
SDLTest_Log("Skipping window positioning tests: %s reports window positioning as unsupported", SDL_GetCurrentVideoDriver());
|
|
goto null_tests;
|
|
}
|
|
|
|
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0) {
|
|
/* The X11 server allows arbitrary window placement, but compositing
|
|
* window managers such as GNOME and KDE force windows to be within
|
|
* desktop bounds.
|
|
*/
|
|
maxxVariation = 2;
|
|
maxyVariation = 2;
|
|
|
|
SDL_GetDisplayUsableBounds(SDL_GetPrimaryDisplay(), &display_bounds);
|
|
} else if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "cocoa") == 0) {
|
|
/* Platform doesn't allow windows with negative Y desktop bounds */
|
|
maxxVariation = 4;
|
|
maxyVariation = 3;
|
|
|
|
SDL_GetDisplayUsableBounds(SDL_GetPrimaryDisplay(), &display_bounds);
|
|
} else {
|
|
/* Platform allows windows to be placed out of bounds */
|
|
maxxVariation = 4;
|
|
maxyVariation = 4;
|
|
|
|
SDL_GetDisplayBounds(SDL_GetPrimaryDisplay(), &display_bounds);
|
|
}
|
|
|
|
for (xVariation = 0; xVariation < maxxVariation; xVariation++) {
|
|
for (yVariation = 0; yVariation < maxyVariation; yVariation++) {
|
|
switch (xVariation) {
|
|
default:
|
|
case 0:
|
|
/* Zero X Position */
|
|
desiredX = display_bounds.x > 0 ? display_bounds.x : 0;
|
|
break;
|
|
case 1:
|
|
/* Random X position inside screen */
|
|
desiredX = SDLTest_RandomIntegerInRange(display_bounds.x + 1, display_bounds.x + 100);
|
|
break;
|
|
case 2:
|
|
/* Random X position outside screen (positive) */
|
|
desiredX = SDLTest_RandomIntegerInRange(10000, 11000);
|
|
break;
|
|
case 3:
|
|
/* Random X position outside screen (negative) */
|
|
desiredX = SDLTest_RandomIntegerInRange(-1000, -100);
|
|
break;
|
|
}
|
|
|
|
switch (yVariation) {
|
|
default:
|
|
case 0:
|
|
/* Zero Y Position */
|
|
desiredY = display_bounds.y > 0 ? display_bounds.y : 0;
|
|
break;
|
|
case 1:
|
|
/* Random Y position inside screen */
|
|
desiredY = SDLTest_RandomIntegerInRange(display_bounds.y + 1, display_bounds.y + 100);
|
|
break;
|
|
case 2:
|
|
/* Random Y position outside screen (positive) */
|
|
desiredY = SDLTest_RandomIntegerInRange(10000, 11000);
|
|
break;
|
|
case 3:
|
|
/* Random Y position outside screen (negative) */
|
|
desiredY = SDLTest_RandomIntegerInRange(-1000, -100);
|
|
break;
|
|
}
|
|
|
|
/* Set position */
|
|
SDL_SetWindowPosition(window, desiredX, desiredY);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowPosition(...,%d,%d)", desiredX, desiredY);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
/* Get position */
|
|
currentX = desiredX + 1;
|
|
currentY = desiredY + 1;
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
|
|
|
|
if (desiredX == currentX && desiredY == currentY) {
|
|
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X position; expected: %d, got: %d", desiredX, currentX);
|
|
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y position; expected: %d, got: %d", desiredY, currentY);
|
|
} else {
|
|
bool hasEvent;
|
|
/* SDL_SetWindowPosition() and SDL_SetWindowSize() will make requests of the window manager and set the internal position and size,
|
|
* and then we get events signaling what actually happened, and they get passed on to the application if they're not what we expect. */
|
|
currentX = desiredX + 1;
|
|
currentY = desiredY + 1;
|
|
hasEvent = getPositionFromEvent(¤tX, ¤tY);
|
|
SDLTest_AssertCheck(hasEvent == true, "Changing position was not honored by WM, checking present of SDL_EVENT_WINDOW_MOVED");
|
|
if (hasEvent) {
|
|
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X position is the position from SDL event; expected: %d, got: %d", desiredX, currentX);
|
|
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y position is the position from SDL event; expected: %d, got: %d", desiredY, currentY);
|
|
}
|
|
}
|
|
|
|
/* Get position X */
|
|
currentX = desiredX + 1;
|
|
SDL_GetWindowPosition(window, ¤tX, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition(&y=NULL)");
|
|
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X position; expected: %d, got: %d", desiredX, currentX);
|
|
|
|
/* Get position Y */
|
|
currentY = desiredY + 1;
|
|
SDL_GetWindowPosition(window, NULL, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition(&x=NULL)");
|
|
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y position; expected: %d, got: %d", desiredY, currentY);
|
|
}
|
|
}
|
|
|
|
null_tests:
|
|
|
|
/* Dummy call with both pointers NULL */
|
|
SDL_GetWindowPosition(window, NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition(&x=NULL,&y=NULL)");
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
/* Set some 'magic' value for later check that nothing was changed */
|
|
referenceX = SDLTest_RandomSint32();
|
|
referenceY = SDLTest_RandomSint32();
|
|
currentX = referenceX;
|
|
currentY = referenceY;
|
|
desiredX = SDLTest_RandomSint32();
|
|
desiredY = SDLTest_RandomSint32();
|
|
|
|
/* Negative tests */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
SDL_GetWindowPosition(NULL, ¤tX, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition(window=NULL)");
|
|
SDLTest_AssertCheck(
|
|
currentX == referenceX && currentY == referenceY,
|
|
"Verify that content of X and Y pointers has not been modified; expected: %d,%d; got: %d,%d",
|
|
referenceX, referenceY,
|
|
currentX, currentY);
|
|
checkInvalidWindowError();
|
|
|
|
SDL_GetWindowPosition(NULL, NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition(NULL, NULL, NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_SetWindowPosition(NULL, desiredX, desiredY);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowPosition(window=NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/* Helper function that checks for an 'Invalid parameter' error */
|
|
static void checkInvalidParameterError(void)
|
|
{
|
|
const char *invalidParameterError = "Parameter";
|
|
const char *lastError;
|
|
|
|
lastError = SDL_GetError();
|
|
SDLTest_AssertPass("SDL_GetError()");
|
|
SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
|
|
if (lastError != NULL) {
|
|
SDLTest_AssertCheck(SDL_strncmp(lastError, invalidParameterError, SDL_strlen(invalidParameterError)) == 0,
|
|
"SDL_GetError(): expected message starts with '%s', was message: '%s'",
|
|
invalidParameterError,
|
|
lastError);
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_GetWindowSize and SDL_SetWindowSize
|
|
*
|
|
* \sa SDL_GetWindowSize
|
|
* \sa SDL_SetWindowSize
|
|
*/
|
|
static int SDLCALL video_getSetWindowSize(void *arg)
|
|
{
|
|
const char *title = "video_getSetWindowSize Test Window";
|
|
SDL_Window *window;
|
|
int result;
|
|
SDL_Rect display;
|
|
int maxwVariation, maxhVariation;
|
|
int wVariation, hVariation;
|
|
int referenceW, referenceH;
|
|
int currentW, currentH;
|
|
int desiredW, desiredH;
|
|
const bool restoreHint = SDL_GetHintBoolean("SDL_BORDERLESS_RESIZABLE_STYLE", true);
|
|
|
|
/* Win32 borderless windows are not resizable by default and need this undocumented hint */
|
|
SDL_SetHint("SDL_BORDERLESS_RESIZABLE_STYLE", "1");
|
|
|
|
/* Get display bounds for size range */
|
|
result = SDL_GetDisplayUsableBounds(SDL_GetPrimaryDisplay(), &display);
|
|
SDLTest_AssertPass("SDL_GetDisplayUsableBounds()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
if (!result) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
if (SDL_SetWindowSize(window, currentW, currentH)) {
|
|
SDLTest_Log("Skipping window resize tests: %s reports window resizing as unsupported", SDL_GetCurrentVideoDriver());
|
|
goto null_tests;
|
|
}
|
|
|
|
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "windows") == 0 ||
|
|
SDL_strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0) {
|
|
/* Platform clips window size to screen size */
|
|
maxwVariation = 4;
|
|
maxhVariation = 4;
|
|
} else {
|
|
/* Platform allows window size >= screen size */
|
|
maxwVariation = 5;
|
|
maxhVariation = 5;
|
|
}
|
|
|
|
for (wVariation = 0; wVariation < maxwVariation; wVariation++) {
|
|
for (hVariation = 0; hVariation < maxhVariation; hVariation++) {
|
|
switch (wVariation) {
|
|
default:
|
|
case 0:
|
|
/* 1 Pixel Wide */
|
|
desiredW = 1;
|
|
break;
|
|
case 1:
|
|
/* Random width inside screen */
|
|
desiredW = SDLTest_RandomIntegerInRange(1, 100);
|
|
break;
|
|
case 2:
|
|
/* Width 1 pixel smaller than screen */
|
|
desiredW = display.w - 1;
|
|
break;
|
|
case 3:
|
|
/* Width at screen size */
|
|
desiredW = display.w;
|
|
break;
|
|
case 4:
|
|
/* Width 1 pixel larger than screen */
|
|
desiredW = display.w + 1;
|
|
break;
|
|
}
|
|
|
|
switch (hVariation) {
|
|
default:
|
|
case 0:
|
|
/* 1 Pixel High */
|
|
desiredH = 1;
|
|
break;
|
|
case 1:
|
|
/* Random height inside screen */
|
|
desiredH = SDLTest_RandomIntegerInRange(1, 100);
|
|
break;
|
|
case 2:
|
|
/* Height 1 pixel smaller than screen */
|
|
desiredH = display.h - 1;
|
|
break;
|
|
case 3:
|
|
/* Height at screen size */
|
|
desiredH = display.h;
|
|
break;
|
|
case 4:
|
|
/* Height 1 pixel larger than screen */
|
|
desiredH = display.h + 1;
|
|
break;
|
|
}
|
|
|
|
/* Set size */
|
|
SDL_SetWindowSize(window, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowSize(...,%d,%d)", desiredW, desiredH);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
/* Get size */
|
|
currentW = desiredW + 1;
|
|
currentH = desiredH + 1;
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
|
|
|
|
if (desiredW == currentW && desiredH == currentH) {
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
|
|
} else {
|
|
bool hasEvent;
|
|
/* SDL_SetWindowPosition() and SDL_SetWindowSize() will make requests of the window manager and set the internal position and size,
|
|
* and then we get events signaling what actually happened, and they get passed on to the application if they're not what we expect. */
|
|
currentW = desiredW + 1;
|
|
currentH = desiredH + 1;
|
|
hasEvent = getSizeFromEvent(¤tW, ¤tH);
|
|
SDLTest_AssertCheck(hasEvent == true, "Changing size was not honored by WM, checking presence of SDL_EVENT_WINDOW_RESIZED");
|
|
if (hasEvent) {
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width is the one from SDL event; expected: %d, got: %d", desiredW, currentW);
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height is the one from SDL event; expected: %d, got: %d", desiredH, currentH);
|
|
}
|
|
}
|
|
|
|
|
|
/* Get just width */
|
|
currentW = desiredW + 1;
|
|
SDL_GetWindowSize(window, ¤tW, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize(&h=NULL)");
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
|
|
|
|
/* Get just height */
|
|
currentH = desiredH + 1;
|
|
SDL_GetWindowSize(window, NULL, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize(&w=NULL)");
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
|
|
}
|
|
}
|
|
|
|
null_tests:
|
|
|
|
/* Dummy call with both pointers NULL */
|
|
SDL_GetWindowSize(window, NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize(&w=NULL,&h=NULL)");
|
|
|
|
/* Negative tests for parameter input */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
for (desiredH = -2; desiredH < 2; desiredH++) {
|
|
for (desiredW = -2; desiredW < 2; desiredW++) {
|
|
if (desiredW <= 0 || desiredH <= 0) {
|
|
SDL_SetWindowSize(window, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowSize(...,%d,%d)", desiredW, desiredH);
|
|
checkInvalidParameterError();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
/* Set some 'magic' value for later check that nothing was changed */
|
|
referenceW = SDLTest_RandomSint32();
|
|
referenceH = SDLTest_RandomSint32();
|
|
currentW = referenceW;
|
|
currentH = referenceH;
|
|
desiredW = SDLTest_RandomSint32();
|
|
desiredH = SDLTest_RandomSint32();
|
|
|
|
/* Negative tests for window input */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
SDL_GetWindowSize(NULL, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize(window=NULL)");
|
|
SDLTest_AssertCheck(
|
|
currentW == referenceW && currentH == referenceH,
|
|
"Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
|
|
referenceW, referenceH,
|
|
currentW, currentH);
|
|
checkInvalidWindowError();
|
|
|
|
SDL_GetWindowSize(NULL, NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize(NULL, NULL, NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_SetWindowSize(NULL, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowSize(window=NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
/* Restore the hint to the previous value */
|
|
SDL_SetHint("SDL_BORDERLESS_RESIZABLE_STYLE", restoreHint ? "1" : "0");
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize
|
|
*
|
|
*/
|
|
static int SDLCALL video_getSetWindowMinimumSize(void *arg)
|
|
{
|
|
const char *title = "video_getSetWindowMinimumSize Test Window";
|
|
SDL_Window *window;
|
|
int result;
|
|
SDL_Rect display;
|
|
int wVariation, hVariation;
|
|
int referenceW, referenceH;
|
|
int currentW, currentH;
|
|
int desiredW = 1;
|
|
int desiredH = 1;
|
|
|
|
/* Get display bounds for size range */
|
|
result = SDL_GetDisplayBounds(SDL_GetPrimaryDisplay(), &display);
|
|
SDLTest_AssertPass("SDL_GetDisplayBounds()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
if (!result) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
for (wVariation = 0; wVariation < 5; wVariation++) {
|
|
for (hVariation = 0; hVariation < 5; hVariation++) {
|
|
switch (wVariation) {
|
|
case 0:
|
|
/* 1 Pixel Wide */
|
|
desiredW = 1;
|
|
break;
|
|
case 1:
|
|
/* Random width inside screen */
|
|
desiredW = SDLTest_RandomIntegerInRange(2, display.w - 1);
|
|
break;
|
|
case 2:
|
|
/* Width at screen size */
|
|
desiredW = display.w;
|
|
break;
|
|
}
|
|
|
|
switch (hVariation) {
|
|
case 0:
|
|
/* 1 Pixel High */
|
|
desiredH = 1;
|
|
break;
|
|
case 1:
|
|
/* Random height inside screen */
|
|
desiredH = SDLTest_RandomIntegerInRange(2, display.h - 1);
|
|
break;
|
|
case 2:
|
|
/* Height at screen size */
|
|
desiredH = display.h;
|
|
break;
|
|
case 4:
|
|
/* Height 1 pixel larger than screen */
|
|
desiredH = display.h + 1;
|
|
break;
|
|
}
|
|
|
|
/* Set size */
|
|
SDL_SetWindowMinimumSize(window, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(...,%d,%d)", desiredW, desiredH);
|
|
|
|
/* Get size */
|
|
currentW = desiredW + 1;
|
|
currentH = desiredH + 1;
|
|
SDL_GetWindowMinimumSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize()");
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
|
|
|
|
/* Get just width */
|
|
currentW = desiredW + 1;
|
|
SDL_GetWindowMinimumSize(window, ¤tW, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&h=NULL)");
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentH);
|
|
|
|
/* Get just height */
|
|
currentH = desiredH + 1;
|
|
SDL_GetWindowMinimumSize(window, NULL, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&w=NULL)");
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredW, currentH);
|
|
}
|
|
}
|
|
|
|
/* Dummy call with both pointers NULL */
|
|
SDL_GetWindowMinimumSize(window, NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&w=NULL,&h=NULL)");
|
|
|
|
/* Negative tests for parameter input */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
for (desiredH = -2; desiredH < 2; desiredH++) {
|
|
for (desiredW = -2; desiredW < 2; desiredW++) {
|
|
if (desiredW < 0 || desiredH < 0) {
|
|
SDL_SetWindowMinimumSize(window, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(...,%d,%d)", desiredW, desiredH);
|
|
checkInvalidParameterError();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
/* Set some 'magic' value for later check that nothing was changed */
|
|
referenceW = SDLTest_RandomSint32();
|
|
referenceH = SDLTest_RandomSint32();
|
|
currentW = referenceW;
|
|
currentH = referenceH;
|
|
desiredW = SDLTest_RandomSint32();
|
|
desiredH = SDLTest_RandomSint32();
|
|
|
|
/* Negative tests for window input */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
SDL_GetWindowMinimumSize(NULL, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(window=NULL)");
|
|
SDLTest_AssertCheck(
|
|
currentW == referenceW && currentH == referenceH,
|
|
"Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
|
|
referenceW, referenceH,
|
|
currentW, currentH);
|
|
checkInvalidWindowError();
|
|
|
|
SDL_GetWindowMinimumSize(NULL, NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(NULL, NULL, NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_SetWindowMinimumSize(NULL, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(window=NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize
|
|
*
|
|
*/
|
|
static int SDLCALL video_getSetWindowMaximumSize(void *arg)
|
|
{
|
|
const char *title = "video_getSetWindowMaximumSize Test Window";
|
|
SDL_Window *window;
|
|
int result;
|
|
SDL_Rect display;
|
|
int wVariation, hVariation;
|
|
int referenceW, referenceH;
|
|
int currentW, currentH;
|
|
int desiredW = 0, desiredH = 0;
|
|
|
|
/* Get display bounds for size range */
|
|
result = SDL_GetDisplayBounds(SDL_GetPrimaryDisplay(), &display);
|
|
SDLTest_AssertPass("SDL_GetDisplayBounds()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
if (!result) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
for (wVariation = 0; wVariation < 3; wVariation++) {
|
|
for (hVariation = 0; hVariation < 3; hVariation++) {
|
|
switch (wVariation) {
|
|
case 0:
|
|
/* 1 Pixel Wide */
|
|
desiredW = 1;
|
|
break;
|
|
case 1:
|
|
/* Random width inside screen */
|
|
desiredW = SDLTest_RandomIntegerInRange(2, display.w - 1);
|
|
break;
|
|
case 2:
|
|
/* Width at screen size */
|
|
desiredW = display.w;
|
|
break;
|
|
}
|
|
|
|
switch (hVariation) {
|
|
case 0:
|
|
/* 1 Pixel High */
|
|
desiredH = 1;
|
|
break;
|
|
case 1:
|
|
/* Random height inside screen */
|
|
desiredH = SDLTest_RandomIntegerInRange(2, display.h - 1);
|
|
break;
|
|
case 2:
|
|
/* Height at screen size */
|
|
desiredH = display.h;
|
|
break;
|
|
}
|
|
|
|
/* Set size */
|
|
SDL_SetWindowMaximumSize(window, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(...,%d,%d)", desiredW, desiredH);
|
|
|
|
/* Get size */
|
|
currentW = desiredW + 1;
|
|
currentH = desiredH + 1;
|
|
SDL_GetWindowMaximumSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize()");
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
|
|
|
|
/* Get just width */
|
|
currentW = desiredW + 1;
|
|
SDL_GetWindowMaximumSize(window, ¤tW, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&h=NULL)");
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentH);
|
|
|
|
/* Get just height */
|
|
currentH = desiredH + 1;
|
|
SDL_GetWindowMaximumSize(window, NULL, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&w=NULL)");
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredW, currentH);
|
|
}
|
|
}
|
|
|
|
/* Dummy call with both pointers NULL */
|
|
SDL_GetWindowMaximumSize(window, NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&w=NULL,&h=NULL)");
|
|
|
|
/* Negative tests for parameter input */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
for (desiredH = -2; desiredH < 2; desiredH++) {
|
|
for (desiredW = -2; desiredW < 2; desiredW++) {
|
|
if (desiredW < 0 || desiredH < 0) {
|
|
SDL_SetWindowMaximumSize(window, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(...,%d,%d)", desiredW, desiredH);
|
|
checkInvalidParameterError();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
/* Set some 'magic' value for later check that nothing was changed */
|
|
referenceW = SDLTest_RandomSint32();
|
|
referenceH = SDLTest_RandomSint32();
|
|
currentW = referenceW;
|
|
currentH = referenceH;
|
|
desiredW = SDLTest_RandomSint32();
|
|
desiredH = SDLTest_RandomSint32();
|
|
|
|
/* Negative tests */
|
|
SDL_ClearError();
|
|
SDLTest_AssertPass("Call to SDL_ClearError()");
|
|
SDL_GetWindowMaximumSize(NULL, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(window=NULL)");
|
|
SDLTest_AssertCheck(
|
|
currentW == referenceW && currentH == referenceH,
|
|
"Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
|
|
referenceW, referenceH,
|
|
currentW, currentH);
|
|
checkInvalidWindowError();
|
|
|
|
SDL_GetWindowMaximumSize(NULL, NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(NULL, NULL, NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
SDL_SetWindowMaximumSize(NULL, desiredW, desiredH);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(window=NULL)");
|
|
checkInvalidWindowError();
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests call to SDL_SetWindowData and SDL_GetWindowData
|
|
*
|
|
* \sa SDL_SetWindowData
|
|
* \sa SDL_GetWindowData
|
|
*/
|
|
static int SDLCALL video_getSetWindowData(void *arg)
|
|
{
|
|
int returnValue = TEST_COMPLETED;
|
|
const char *title = "video_setGetWindowData Test Window";
|
|
SDL_Window *window;
|
|
const char *referenceName = "TestName";
|
|
const char *name = "TestName";
|
|
const char *referenceName2 = "TestName2";
|
|
const char *name2 = "TestName2";
|
|
int datasize;
|
|
char *referenceUserdata = NULL;
|
|
char *userdata = NULL;
|
|
char *referenceUserdata2 = NULL;
|
|
char *userdata2 = NULL;
|
|
char *result;
|
|
int iteration;
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
/* Create testdata */
|
|
datasize = SDLTest_RandomIntegerInRange(1, 32);
|
|
referenceUserdata = SDLTest_RandomAsciiStringOfSize(datasize);
|
|
if (!referenceUserdata) {
|
|
returnValue = TEST_ABORTED;
|
|
goto cleanup;
|
|
}
|
|
userdata = SDL_strdup(referenceUserdata);
|
|
if (!userdata) {
|
|
returnValue = TEST_ABORTED;
|
|
goto cleanup;
|
|
}
|
|
datasize = SDLTest_RandomIntegerInRange(1, 32);
|
|
referenceUserdata2 = SDLTest_RandomAsciiStringOfSize(datasize);
|
|
if (!referenceUserdata2) {
|
|
returnValue = TEST_ABORTED;
|
|
goto cleanup;
|
|
}
|
|
userdata2 = SDL_strdup(referenceUserdata2);
|
|
if (!userdata2) {
|
|
returnValue = TEST_ABORTED;
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Get non-existent data */
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), name, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name);
|
|
SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
|
|
/* Set data */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), name, userdata);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s)", name, userdata);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
|
|
|
|
/* Get data (twice) */
|
|
for (iteration = 1; iteration <= 2; iteration++) {
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), name, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [iteration %d]", name, iteration);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
}
|
|
|
|
/* Set data again twice */
|
|
for (iteration = 1; iteration <= 2; iteration++) {
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), name, userdata);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [iteration %d]", name, userdata, iteration);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
|
|
}
|
|
|
|
/* Get data again */
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), name, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [again]", name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
|
|
/* Set data with new data */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), name, userdata2);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [new userdata]", name, userdata2);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2);
|
|
|
|
/* Set data with new data again */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), name, userdata2);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [new userdata again]", name, userdata2);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2);
|
|
|
|
/* Get new data */
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), name, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata2, result);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
|
|
/* Set data with NULL to clear */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), name, NULL);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,NULL)", name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2);
|
|
|
|
/* Set data with NULL to clear again */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), name, NULL);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,NULL) [again]", name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2);
|
|
|
|
/* Get non-existent data */
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), name, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name);
|
|
SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
|
|
/* Get non-existent data new name */
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), name2, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name2);
|
|
SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName2, name2) == 0, "Validate that name2 was not changed, expected: %s, got: %s", referenceName2, name2);
|
|
|
|
/* Set data (again) */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), name, userdata);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [again, after clear]", name, userdata);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
|
|
|
|
/* Get data (again) */
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), name, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [again, after clear]", name);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result);
|
|
SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
|
|
|
|
/* Set data with NULL name, valid userdata */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), NULL, userdata);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(name=NULL)");
|
|
checkInvalidParameterError();
|
|
|
|
/* Set data with empty name, valid userdata */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), "", userdata);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(name='')");
|
|
checkInvalidParameterError();
|
|
|
|
/* Set data with NULL name, NULL userdata */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(name=NULL,userdata=NULL)");
|
|
checkInvalidParameterError();
|
|
|
|
/* Set data with empty name, NULL userdata */
|
|
SDL_SetPointerProperty(SDL_GetWindowProperties(window), "", NULL);
|
|
SDLTest_AssertPass("Call to SDL_SetWindowData(name='',userdata=NULL)");
|
|
checkInvalidParameterError();
|
|
|
|
/* Get data with NULL name */
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), NULL, NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(name=NULL)");
|
|
SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
|
|
|
|
/* Get data with empty name */
|
|
result = (char *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), "", NULL);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowData(name='')");
|
|
SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
cleanup:
|
|
SDL_free(referenceUserdata);
|
|
SDL_free(referenceUserdata2);
|
|
SDL_free(userdata);
|
|
SDL_free(userdata2);
|
|
|
|
return returnValue;
|
|
}
|
|
|
|
/**
|
|
* Tests the functionality of the SDL_WINDOWPOS_CENTERED_DISPLAY along with SDL_WINDOW_FULLSCREEN.
|
|
*
|
|
* Especially useful when run on a multi-monitor system with different DPI scales per monitor,
|
|
* to test that the window size is maintained when moving between monitors.
|
|
*
|
|
* As the Wayland windowing protocol does not allow application windows to control their position in the
|
|
* desktop space, coupled with the general asynchronous nature of Wayland compositors, the positioning
|
|
* tests don't work in windowed mode and are unreliable in fullscreen mode, thus are disabled when using
|
|
* the Wayland video driver. All that can be done is check that the windows are the expected size.
|
|
*/
|
|
static int SDLCALL video_setWindowCenteredOnDisplay(void *arg)
|
|
{
|
|
SDL_DisplayID *displays;
|
|
SDL_Window *window;
|
|
const char *title = "video_setWindowCenteredOnDisplay Test Window";
|
|
int x, y, w, h;
|
|
int xVariation, yVariation;
|
|
int displayNum;
|
|
int result;
|
|
SDL_Rect display0, display1;
|
|
const char *video_driver = SDL_GetCurrentVideoDriver();
|
|
bool video_driver_is_wayland = SDL_strcmp(video_driver, "wayland") == 0;
|
|
bool video_driver_is_emscripten = SDL_strcmp(video_driver, "emscripten") == 0;
|
|
|
|
displays = SDL_GetDisplays(&displayNum);
|
|
if (displays) {
|
|
|
|
/* Get display bounds */
|
|
result = SDL_GetDisplayUsableBounds(displays[0 % displayNum], &display0);
|
|
SDLTest_AssertPass("SDL_GetDisplayUsableBounds()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
if (!result) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
result = SDL_GetDisplayUsableBounds(displays[1 % displayNum], &display1);
|
|
SDLTest_AssertPass("SDL_GetDisplayUsableBounds()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
if (!result) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
for (xVariation = 0; xVariation < 2; xVariation++) {
|
|
for (yVariation = 0; yVariation < 2; yVariation++) {
|
|
int currentX = 0, currentY = 0;
|
|
int currentW = 0, currentH = 0;
|
|
int expectedX = 0, expectedY = 0;
|
|
int currentDisplay;
|
|
int expectedDisplay;
|
|
SDL_Rect expectedDisplayRect, expectedFullscreenRect;
|
|
SDL_PropertiesID props;
|
|
|
|
/* xVariation is the display we start on */
|
|
expectedDisplay = displays[xVariation % displayNum];
|
|
x = SDL_WINDOWPOS_CENTERED_DISPLAY(expectedDisplay);
|
|
y = SDL_WINDOWPOS_CENTERED_DISPLAY(expectedDisplay);
|
|
w = SDLTest_RandomIntegerInRange(640, 800);
|
|
h = SDLTest_RandomIntegerInRange(400, 600);
|
|
expectedDisplayRect = (xVariation == 0) ? display0 : display1;
|
|
expectedX = (expectedDisplayRect.x + ((expectedDisplayRect.w - w) / 2));
|
|
expectedY = (expectedDisplayRect.y + ((expectedDisplayRect.h - h) / 2));
|
|
|
|
props = SDL_CreateProperties();
|
|
SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING, title);
|
|
SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, x);
|
|
SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, y);
|
|
SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, w);
|
|
SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, h);
|
|
SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN, true);
|
|
window = SDL_CreateWindowWithProperties(props);
|
|
SDL_DestroyProperties(props);
|
|
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN)", x, y, w, h);
|
|
SDLTest_AssertCheck(window != NULL, "Validate that returned window is not NULL");
|
|
|
|
/* Wayland windows require that a frame be presented before they are fully mapped and visible onscreen. */
|
|
if (video_driver_is_wayland) {
|
|
SDL_Renderer *renderer = SDL_CreateRenderer(window, NULL);
|
|
|
|
if (renderer) {
|
|
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
|
|
SDL_RenderClear(renderer);
|
|
SDL_RenderPresent(renderer);
|
|
|
|
/* Some desktops don't display the window immediately after presentation,
|
|
* so delay to give the window time to actually appear on the desktop.
|
|
*/
|
|
SDL_Delay(100);
|
|
} else {
|
|
SDLTest_Log("Unable to create a renderer, tests may fail under Wayland");
|
|
}
|
|
}
|
|
|
|
/* Check the window is centered on the requested display */
|
|
currentDisplay = SDL_GetDisplayForWindow(window);
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
|
|
if (video_driver_is_wayland) {
|
|
SDLTest_Log("Skipping display ID validation: %s driver does not support window positioning", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentDisplay == expectedDisplay, "Validate display ID (current: %d, expected: %d)", currentDisplay, expectedDisplay);
|
|
}
|
|
if (video_driver_is_emscripten) {
|
|
SDLTest_Log("Skipping window size validation: %s driver does not support window resizing", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentW == w, "Validate width (current: %d, expected: %d)", currentW, w);
|
|
SDLTest_AssertCheck(currentH == h, "Validate height (current: %d, expected: %d)", currentH, h);
|
|
}
|
|
if (video_driver_is_emscripten || video_driver_is_wayland) {
|
|
SDLTest_Log("Skipping window position validation: %s driver does not support window positioning", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentX == expectedX, "Validate x (current: %d, expected: %d)", currentX, expectedX);
|
|
SDLTest_AssertCheck(currentY == expectedY, "Validate y (current: %d, expected: %d)", currentY, expectedY);
|
|
}
|
|
|
|
/* Enter fullscreen desktop */
|
|
SDL_SetWindowPosition(window, x, y);
|
|
result = SDL_SetWindowFullscreen(window, true);
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
/* Check we are filling the full display */
|
|
currentDisplay = SDL_GetDisplayForWindow(window);
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
|
|
/* Get the expected fullscreen rect.
|
|
* This needs to be queried after window creation and positioning as some drivers can alter the
|
|
* usable bounds based on the window scaling mode.
|
|
*/
|
|
result = SDL_GetDisplayBounds(expectedDisplay, &expectedFullscreenRect);
|
|
SDLTest_AssertPass("SDL_GetDisplayBounds()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
if (video_driver_is_wayland) {
|
|
SDLTest_Log("Skipping display ID validation: Wayland driver does not support window positioning");
|
|
} else {
|
|
SDLTest_AssertCheck(currentDisplay == expectedDisplay, "Validate display ID (current: %d, expected: %d)", currentDisplay, expectedDisplay);
|
|
}
|
|
|
|
if (video_driver_is_emscripten) {
|
|
SDLTest_Log("Skipping window position validation: %s driver does not support window resizing", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentW == expectedFullscreenRect.w, "Validate width (current: %d, expected: %d)", currentW, expectedFullscreenRect.w);
|
|
SDLTest_AssertCheck(currentH == expectedFullscreenRect.h, "Validate height (current: %d, expected: %d)", currentH, expectedFullscreenRect.h);
|
|
}
|
|
if (video_driver_is_emscripten || video_driver_is_wayland) {
|
|
SDLTest_Log("Skipping window position validation: %s driver does not support window positioning", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentX == expectedFullscreenRect.x, "Validate x (current: %d, expected: %d)", currentX, expectedFullscreenRect.x);
|
|
SDLTest_AssertCheck(currentY == expectedFullscreenRect.y, "Validate y (current: %d, expected: %d)", currentY, expectedFullscreenRect.y);
|
|
}
|
|
|
|
/* Leave fullscreen desktop */
|
|
result = SDL_SetWindowFullscreen(window, false);
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
/* Check window was restored correctly */
|
|
currentDisplay = SDL_GetDisplayForWindow(window);
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
|
|
if (video_driver_is_wayland) {
|
|
SDLTest_Log("Skipping display ID validation: %s driver does not support window positioning", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentDisplay == expectedDisplay, "Validate display index (current: %d, expected: %d)", currentDisplay, expectedDisplay);
|
|
}
|
|
if (video_driver_is_emscripten) {
|
|
SDLTest_Log("Skipping window position validation: %s driver does not support window resizing", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentW == w, "Validate width (current: %d, expected: %d)", currentW, w);
|
|
SDLTest_AssertCheck(currentH == h, "Validate height (current: %d, expected: %d)", currentH, h);
|
|
}
|
|
if (video_driver_is_emscripten || video_driver_is_wayland) {
|
|
SDLTest_Log("Skipping window position validation: %s driver does not support window positioning", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentX == expectedX, "Validate x (current: %d, expected: %d)", currentX, expectedX);
|
|
SDLTest_AssertCheck(currentY == expectedY, "Validate y (current: %d, expected: %d)", currentY, expectedY);
|
|
}
|
|
|
|
/* Center on display yVariation, and check window properties */
|
|
|
|
expectedDisplay = displays[yVariation % displayNum];
|
|
x = SDL_WINDOWPOS_CENTERED_DISPLAY(expectedDisplay);
|
|
y = SDL_WINDOWPOS_CENTERED_DISPLAY(expectedDisplay);
|
|
expectedDisplayRect = (yVariation == 0) ? display0 : display1;
|
|
expectedX = (expectedDisplayRect.x + ((expectedDisplayRect.w - w) / 2));
|
|
expectedY = (expectedDisplayRect.y + ((expectedDisplayRect.h - h) / 2));
|
|
SDL_SetWindowPosition(window, x, y);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
currentDisplay = SDL_GetDisplayForWindow(window);
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
|
|
if (video_driver_is_wayland) {
|
|
SDLTest_Log("Skipping display ID validation: %s driver does not support window positioning", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentDisplay == expectedDisplay, "Validate display ID (current: %d, expected: %d)", currentDisplay, expectedDisplay);
|
|
}
|
|
if (video_driver_is_emscripten) {
|
|
SDLTest_Log("Skipping window position validation: %s driver does not support window resizing", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentW == w, "Validate width (current: %d, expected: %d)", currentW, w);
|
|
SDLTest_AssertCheck(currentH == h, "Validate height (current: %d, expected: %d)", currentH, h);
|
|
}
|
|
if (video_driver_is_emscripten || video_driver_is_wayland) {
|
|
SDLTest_Log("Skipping window position validation: %s driver does not support window positioning", video_driver);
|
|
} else {
|
|
SDLTest_AssertCheck(currentX == expectedX, "Validate x (current: %d, expected: %d)", currentX, expectedX);
|
|
SDLTest_AssertCheck(currentY == expectedY, "Validate y (current: %d, expected: %d)", currentY, expectedY);
|
|
}
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
}
|
|
}
|
|
SDL_free(displays);
|
|
}
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests calls to SDL_MaximizeWindow(), SDL_RestoreWindow(), and SDL_SetWindowFullscreen(),
|
|
* interspersed with calls to set the window size and position, and verifies the flags,
|
|
* sizes, and positions of maximized, fullscreen, and restored windows.
|
|
*
|
|
* NOTE: This test is good on Mac, Win32, GNOME, and KDE (Wayland and X11). Other *nix
|
|
* desktops, particularly tiling desktops, may not support the expected behavior,
|
|
* so don't be surprised if this fails.
|
|
*/
|
|
static int SDLCALL video_getSetWindowState(void *arg)
|
|
{
|
|
const char *title = "video_getSetWindowState Test Window";
|
|
SDL_Window *window;
|
|
int result;
|
|
SDL_Rect display;
|
|
SDL_WindowFlags flags;
|
|
int windowedX, windowedY;
|
|
int currentX, currentY;
|
|
int desiredX = 0, desiredY = 0;
|
|
int windowedW, windowedH;
|
|
int currentW, currentH;
|
|
int desiredW = 0, desiredH = 0;
|
|
SDL_WindowFlags skipFlags = 0;
|
|
const bool restoreHint = SDL_GetHintBoolean("SDL_BORDERLESS_RESIZABLE_STYLE", true);
|
|
const bool skipPos = SDL_strcmp(SDL_GetCurrentVideoDriver(), "wayland") == 0;
|
|
|
|
/* This test is known to be good only on GNOME and KDE. At the time of writing, Weston seems to have maximize related bugs
|
|
* that prevent it from running correctly (no configure events are received when unsetting maximize), and tiling window
|
|
* managers such as Sway have fundamental behavioral differences that conflict with it.
|
|
*
|
|
* Other desktops can be enabled in the future as required.
|
|
*/
|
|
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "wayland") == 0 || SDL_strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0) {
|
|
const char *desktop = SDL_GetEnvironmentVariable(SDL_GetEnvironment(), "XDG_CURRENT_DESKTOP");
|
|
if (SDL_strcmp(desktop, "GNOME") != 0 && SDL_strcmp(desktop, "KDE") != 0) {
|
|
SDLTest_Log("Skipping test video_getSetWindowState: desktop environment %s not supported", desktop);
|
|
return TEST_SKIPPED;
|
|
}
|
|
}
|
|
|
|
/* Win32 borderless windows are not resizable by default and need this undocumented hint */
|
|
SDL_SetHint("SDL_BORDERLESS_RESIZABLE_STYLE", "1");
|
|
|
|
/* Call against new test window */
|
|
window = createVideoSuiteTestWindow(title);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
SDL_GetWindowSize(window, &windowedW, &windowedH);
|
|
SDLTest_AssertPass("SDL_GetWindowSize()");
|
|
|
|
SDL_GetWindowPosition(window, &windowedX, &windowedY);
|
|
SDLTest_AssertPass("SDL_GetWindowPosition()");
|
|
|
|
if (skipPos) {
|
|
SDLTest_Log("Skipping positioning tests: %s reports window positioning as unsupported", SDL_GetCurrentVideoDriver());
|
|
}
|
|
|
|
/* Maximize and check the dimensions */
|
|
result = SDL_MaximizeWindow(window);
|
|
SDLTest_AssertPass("SDL_MaximizeWindow()");
|
|
if (!result) {
|
|
SDLTest_Log("Skipping state transition tests: %s reports window maximizing as unsupported", SDL_GetCurrentVideoDriver());
|
|
skipFlags |= SDL_WINDOW_MAXIMIZED;
|
|
goto minimize_test;
|
|
}
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
flags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck(flags & SDL_WINDOW_MAXIMIZED, "Verify the `SDL_WINDOW_MAXIMIZED` flag is set: %s", (flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
|
|
|
|
/* Check that the maximized window doesn't extend beyond the usable display bounds.
|
|
* FIXME: Maximizing Win32 borderless windows is broken, so this always fails.
|
|
* Skip it for now.
|
|
*/
|
|
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "windows") != 0) {
|
|
result = SDL_GetDisplayUsableBounds(SDL_GetDisplayForWindow(window), &display);
|
|
SDLTest_AssertPass("SDL_GetDisplayUsableBounds()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
desiredW = display.w;
|
|
desiredH = display.h;
|
|
currentW = windowedW + 1;
|
|
currentH = windowedH + 1;
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(currentW <= desiredW, "Verify returned width; expected: <= %d, got: %d", desiredW,
|
|
currentW);
|
|
SDLTest_AssertCheck(currentH <= desiredH, "Verify returned height; expected: <= %d, got: %d", desiredH,
|
|
currentH);
|
|
}
|
|
|
|
/* Restore and check the dimensions */
|
|
result = SDL_RestoreWindow(window);
|
|
SDLTest_AssertPass("SDL_RestoreWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
flags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck(!(flags & SDL_WINDOW_MAXIMIZED), "Verify that the `SDL_WINDOW_MAXIMIZED` flag is cleared: %s", !(flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
|
|
|
|
if (!skipPos) {
|
|
currentX = windowedX + 1;
|
|
currentY = windowedY + 1;
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
|
|
SDLTest_AssertCheck(windowedX == currentX, "Verify returned X coordinate; expected: %d, got: %d", windowedX, currentX);
|
|
SDLTest_AssertCheck(windowedY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", windowedY, currentY);
|
|
}
|
|
|
|
currentW = windowedW + 1;
|
|
currentH = windowedH + 1;
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(windowedW == currentW, "Verify returned width; expected: %d, got: %d", windowedW, currentW);
|
|
SDLTest_AssertCheck(windowedH == currentH, "Verify returned height; expected: %d, got: %d", windowedH, currentH);
|
|
|
|
/* Maximize, then immediately restore */
|
|
result = SDL_MaximizeWindow(window);
|
|
SDLTest_AssertPass("SDL_MaximizeWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_RestoreWindow(window);
|
|
SDLTest_AssertPass("SDL_RestoreWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
flags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck(!(flags & SDL_WINDOW_MAXIMIZED), "Verify that the `SDL_WINDOW_MAXIMIZED` flag is cleared: %s", !(flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
|
|
|
|
/* Make sure the restored size and position matches the original windowed size and position. */
|
|
if (!skipPos) {
|
|
currentX = windowedX + 1;
|
|
currentY = windowedY + 1;
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
|
|
SDLTest_AssertCheck(windowedX == currentX, "Verify returned X coordinate; expected: %d, got: %d", windowedX, currentX);
|
|
SDLTest_AssertCheck(windowedY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", windowedY, currentY);
|
|
}
|
|
|
|
currentW = windowedW + 1;
|
|
currentH = windowedH + 1;
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(windowedW == currentW, "Verify returned width; expected: %d, got: %d", windowedW, currentW);
|
|
SDLTest_AssertCheck(windowedH == currentH, "Verify returned height; expected: %d, got: %d", windowedH, currentH);
|
|
|
|
/* Maximize, then enter fullscreen */
|
|
result = SDL_MaximizeWindow(window);
|
|
SDLTest_AssertPass("SDL_MaximizeWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SetWindowFullscreen(window, true);
|
|
SDLTest_AssertPass("SDL_SetWindowFullscreen(true)");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
flags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck(flags & SDL_WINDOW_FULLSCREEN, "Verify the `SDL_WINDOW_FULLSCREEN` flag is set: %s", (flags & SDL_WINDOW_FULLSCREEN) ? "true" : "false");
|
|
SDLTest_AssertCheck(!(flags & SDL_WINDOW_MAXIMIZED), "Verify the `SDL_WINDOW_MAXIMIZED` flag is cleared: %s", !(flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
|
|
|
|
/* Verify the fullscreen size and position */
|
|
result = SDL_GetDisplayBounds(SDL_GetDisplayForWindow(window), &display);
|
|
SDLTest_AssertPass("SDL_GetDisplayBounds()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
if (!skipPos) {
|
|
desiredX = display.x;
|
|
desiredY = display.y;
|
|
currentX = windowedX + 1;
|
|
currentY = windowedY + 1;
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
|
|
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X coordinate; expected: %d, got: %d", desiredX, currentX);
|
|
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", desiredY, currentY);
|
|
}
|
|
|
|
desiredW = display.w;
|
|
desiredH = display.h;
|
|
currentW = windowedW + 1;
|
|
currentH = windowedH + 1;
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(currentW == desiredW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
|
|
SDLTest_AssertCheck(currentH == desiredH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
|
|
|
|
/* Leave fullscreen and restore the window */
|
|
result = SDL_SetWindowFullscreen(window, false);
|
|
SDLTest_AssertPass("SDL_SetWindowFullscreen(false)");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_RestoreWindow(window);
|
|
SDLTest_AssertPass("SDL_RestoreWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
flags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck(!(flags & SDL_WINDOW_MAXIMIZED), "Verify that the `SDL_WINDOW_MAXIMIZED` flag is cleared: %s", !(flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
|
|
|
|
/* Make sure the restored size and position matches the original windowed size and position. */
|
|
if (!skipPos) {
|
|
currentX = windowedX + 1;
|
|
currentY = windowedY + 1;
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
|
|
SDLTest_AssertCheck(windowedX == currentX, "Verify returned X coordinate; expected: %d, got: %d", windowedX, currentX);
|
|
SDLTest_AssertCheck(windowedY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", windowedY, currentY);
|
|
}
|
|
|
|
currentW = windowedW + 1;
|
|
currentH = windowedH + 1;
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(windowedW == currentW, "Verify returned width; expected: %d, got: %d", windowedW, currentW);
|
|
SDLTest_AssertCheck(windowedH == currentH, "Verify returned height; expected: %d, got: %d", windowedH, currentH);
|
|
|
|
/* Maximize, change size, and restore */
|
|
result = SDL_MaximizeWindow(window);
|
|
SDLTest_AssertPass("SDL_MaximizeWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
desiredW = windowedW + 10;
|
|
desiredH = windowedH + 10;
|
|
result = SDL_SetWindowSize(window, desiredW, desiredH);
|
|
SDLTest_AssertPass("SDL_SetWindowSize()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
if (!skipPos) {
|
|
desiredX = windowedX + 10;
|
|
desiredY = windowedY + 10;
|
|
result = SDL_SetWindowPosition(window, desiredX, desiredY);
|
|
SDLTest_AssertPass("SDL_SetWindowPosition()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
}
|
|
|
|
result = SDL_RestoreWindow(window);
|
|
SDLTest_AssertPass("SDL_RestoreWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
flags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck(!(flags & SDL_WINDOW_MAXIMIZED), "Verify that the `SDL_WINDOW_MAXIMIZED` flag is cleared: %s", !(flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
|
|
|
|
if (!skipPos) {
|
|
currentX = desiredX + 1;
|
|
currentY = desiredY + 1;
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
|
|
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X coordinate; expected: %d, got: %d", desiredX, currentX);
|
|
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", desiredY, currentY);
|
|
}
|
|
|
|
currentW = desiredW + 1;
|
|
currentH = desiredH + 1;
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
|
|
|
|
/* Change size and position, maximize and restore */
|
|
desiredW = windowedW - 5;
|
|
desiredH = windowedH - 5;
|
|
result = SDL_SetWindowSize(window, desiredW, desiredH);
|
|
SDLTest_AssertPass("SDL_SetWindowSize()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
if (!skipPos) {
|
|
desiredX = windowedX + 5;
|
|
desiredY = windowedY + 5;
|
|
result = SDL_SetWindowPosition(window, desiredX, desiredY);
|
|
SDLTest_AssertPass("SDL_SetWindowPosition()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
}
|
|
|
|
result = SDL_MaximizeWindow(window);
|
|
SDLTest_AssertPass("SDL_MaximizeWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_RestoreWindow(window);
|
|
SDLTest_AssertPass("SDL_RestoreWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
flags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck(!(flags & SDL_WINDOW_MAXIMIZED), "Verify that the `SDL_WINDOW_MAXIMIZED` flag is cleared: %s", !(flags & SDL_WINDOW_MAXIMIZED) ? "true" : "false");
|
|
|
|
if (!skipPos) {
|
|
currentX = desiredX + 1;
|
|
currentY = desiredY + 1;
|
|
SDL_GetWindowPosition(window, ¤tX, ¤tY);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
|
|
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X coordinate; expected: %d, got: %d", desiredX, currentX);
|
|
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y coordinate; expected: %d, got: %d", desiredY, currentY);
|
|
}
|
|
|
|
currentW = desiredW + 1;
|
|
currentH = desiredH + 1;
|
|
SDL_GetWindowSize(window, ¤tW, ¤tH);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
|
|
SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
|
|
|
|
minimize_test:
|
|
|
|
/* Minimize */
|
|
result = SDL_MinimizeWindow(window);
|
|
if (result) {
|
|
SDLTest_AssertPass("SDL_MinimizeWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
result = SDL_SyncWindow(window);
|
|
SDLTest_AssertPass("SDL_SyncWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
flags = SDL_GetWindowFlags(window);
|
|
SDLTest_AssertPass("SDL_GetWindowFlags()");
|
|
SDLTest_AssertCheck(flags & SDL_WINDOW_MINIMIZED, "Verify that the `SDL_WINDOW_MINIMIZED` flag is set: %s", (flags & SDL_WINDOW_MINIMIZED) ? "true" : "false");
|
|
} else {
|
|
SDLTest_Log("Skipping minimize test: %s reports window minimizing as unsupported", SDL_GetCurrentVideoDriver());
|
|
skipFlags |= SDL_WINDOW_MINIMIZED;
|
|
}
|
|
|
|
/* Clean up */
|
|
destroyVideoSuiteTestWindow(window);
|
|
|
|
/* Restore the hint to the previous value */
|
|
SDL_SetHint("SDL_BORDERLESS_RESIZABLE_STYLE", restoreHint ? "1" : "0");
|
|
|
|
return skipFlags != (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED) ? TEST_COMPLETED : TEST_SKIPPED;
|
|
}
|
|
|
|
static int SDLCALL video_createMinimized(void *arg)
|
|
{
|
|
const char *title = "video_createMinimized Test Window";
|
|
int result;
|
|
SDL_Window *window;
|
|
int windowedX, windowedY;
|
|
int windowedW, windowedH;
|
|
|
|
/* Call against new test window */
|
|
window = SDL_CreateWindow(title, 320, 200, SDL_WINDOW_MINIMIZED);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
SDL_GetWindowSize(window, &windowedW, &windowedH);
|
|
SDLTest_AssertPass("SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(windowedW > 0 && windowedH > 0, "Verify return value; expected: 320x200, got: %dx%d", windowedW, windowedH);
|
|
|
|
SDL_GetWindowSizeInPixels(window, &windowedW, &windowedH);
|
|
SDLTest_AssertPass("SDL_GetWindowSizeInPixels()");
|
|
SDLTest_AssertCheck(windowedW > 0 && windowedH > 0, "Verify return value; expected: > 0, got: %dx%d", windowedW, windowedH);
|
|
|
|
SDL_GetWindowPosition(window, &windowedX, &windowedY);
|
|
SDLTest_AssertPass("SDL_GetWindowPosition()");
|
|
SDLTest_AssertCheck(windowedX >= 0 && windowedY >= 0, "Verify return value; expected: >= 0, got: %d,%d", windowedX, windowedY);
|
|
|
|
if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED) {
|
|
result = SDL_RestoreWindow(window);
|
|
SDLTest_AssertPass("SDL_RestoreWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
} else {
|
|
SDLTest_Log("Requested minimized window on creation, but that isn't supported on this platform.");
|
|
}
|
|
|
|
SDL_DestroyWindow(window);
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
static int SDLCALL video_createMaximized(void *arg)
|
|
{
|
|
const char *title = "video_createMaximized Test Window";
|
|
int result;
|
|
SDL_Window *window;
|
|
int windowedX, windowedY;
|
|
int windowedW, windowedH;
|
|
|
|
/* Call against new test window */
|
|
window = SDL_CreateWindow(title, 320, 200, SDL_WINDOW_MAXIMIZED);
|
|
if (!window) {
|
|
return TEST_ABORTED;
|
|
}
|
|
|
|
SDL_GetWindowSize(window, &windowedW, &windowedH);
|
|
SDLTest_AssertPass("SDL_GetWindowSize()");
|
|
SDLTest_AssertCheck(windowedW > 0 && windowedH > 0, "Verify return value; expected: 320x200, got: %dx%d", windowedW, windowedH);
|
|
|
|
SDL_GetWindowSizeInPixels(window, &windowedW, &windowedH);
|
|
SDLTest_AssertPass("SDL_GetWindowSizeInPixels()");
|
|
SDLTest_AssertCheck(windowedW > 0 && windowedH > 0, "Verify return value; expected: > 0, got: %dx%d", windowedW, windowedH);
|
|
|
|
SDL_GetWindowPosition(window, &windowedX, &windowedY);
|
|
SDLTest_AssertPass("SDL_GetWindowPosition()");
|
|
SDLTest_AssertCheck(windowedX >= 0 && windowedY >= 0, "Verify return value; expected: >= 0, got: %d,%d", windowedX, windowedY);
|
|
|
|
if (SDL_GetWindowFlags(window) & SDL_WINDOW_MAXIMIZED) {
|
|
result = SDL_RestoreWindow(window);
|
|
SDLTest_AssertPass("SDL_RestoreWindow()");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
} else {
|
|
SDLTest_Log("Requested maximized window on creation, but that isn't supported on this platform.");
|
|
}
|
|
|
|
SDL_DestroyWindow(window);
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/**
|
|
* Tests window surface functionality
|
|
*/
|
|
static int SDLCALL video_getWindowSurface(void *arg)
|
|
{
|
|
const char *title = "video_getWindowSurface Test Window";
|
|
SDL_Window *window;
|
|
SDL_Surface *surface;
|
|
SDL_Renderer *renderer;
|
|
const char *renderer_name = NULL;
|
|
int result;
|
|
|
|
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "dummy") == 0) {
|
|
renderer_name = SDL_SOFTWARE_RENDERER;
|
|
}
|
|
|
|
/* Make sure we're testing interaction with an accelerated renderer */
|
|
SDL_SetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION, "1");
|
|
|
|
window = SDL_CreateWindow(title, 320, 320, 0);
|
|
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',320,320,0)");
|
|
SDLTest_AssertCheck(window != NULL, "Validate that returned window is not NULL");
|
|
|
|
surface = SDL_GetWindowSurface(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSurface(window)");
|
|
SDLTest_AssertCheck(surface != NULL, "Validate that returned surface is not NULL");
|
|
SDLTest_AssertCheck(SDL_WindowHasSurface(window), "Validate that window has a surface");
|
|
|
|
result = SDL_UpdateWindowSurface(window);
|
|
SDLTest_AssertPass("Call to SDL_UpdateWindowSurface(window)");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
|
|
/* We shouldn't be able to create a renderer on a window with a surface */
|
|
renderer = SDL_CreateRenderer(window, renderer_name);
|
|
SDLTest_AssertPass("Call to SDL_CreateRenderer(window, %s)", renderer_name);
|
|
SDLTest_AssertCheck(renderer == NULL, "Validate that returned renderer is NULL");
|
|
|
|
result = SDL_DestroyWindowSurface(window);
|
|
SDLTest_AssertPass("Call to SDL_DestroyWindowSurface(window)");
|
|
SDLTest_AssertCheck(result == true, "Verify return value; expected: true, got: %d", result);
|
|
SDLTest_AssertCheck(!SDL_WindowHasSurface(window), "Validate that window does not have a surface");
|
|
|
|
/* We should be able to create a renderer on the window now */
|
|
renderer = SDL_CreateRenderer(window, renderer_name);
|
|
SDLTest_AssertPass("Call to SDL_CreateRenderer(window, %s)", renderer_name);
|
|
SDLTest_AssertCheck(renderer != NULL, "Validate that returned renderer is not NULL");
|
|
|
|
/* We should not be able to create a window surface now, unless it was created by the renderer */
|
|
if (!SDL_WindowHasSurface(window)) {
|
|
surface = SDL_GetWindowSurface(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSurface(window)");
|
|
SDLTest_AssertCheck(surface == NULL, "Validate that returned surface is NULL");
|
|
}
|
|
|
|
SDL_DestroyRenderer(renderer);
|
|
SDLTest_AssertPass("Call to SDL_DestroyRenderer(renderer)");
|
|
SDLTest_AssertCheck(!SDL_WindowHasSurface(window), "Validate that window does not have a surface");
|
|
|
|
/* We should be able to create a window surface again */
|
|
surface = SDL_GetWindowSurface(window);
|
|
SDLTest_AssertPass("Call to SDL_GetWindowSurface(window)");
|
|
SDLTest_AssertCheck(surface != NULL, "Validate that returned surface is not NULL");
|
|
SDLTest_AssertCheck(SDL_WindowHasSurface(window), "Validate that window has a surface");
|
|
|
|
/* Clean up */
|
|
SDL_DestroyWindow(window);
|
|
|
|
return TEST_COMPLETED;
|
|
}
|
|
|
|
/* ================= Test References ================== */
|
|
|
|
/* Video test cases */
|
|
static const SDLTest_TestCaseReference videoTestEnableDisableScreensaver = {
|
|
video_enableDisableScreensaver, "video_enableDisableScreensaver", "Enable and disable screenaver while checking state", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestCreateWindowVariousSizes = {
|
|
video_createWindowVariousSizes, "video_createWindowVariousSizes", "Create windows with various sizes", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestCreateWindowVariousFlags = {
|
|
video_createWindowVariousFlags, "video_createWindowVariousFlags", "Create windows using various flags", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetWindowFlags = {
|
|
video_getWindowFlags, "video_getWindowFlags", "Get window flags set during SDL_CreateWindow", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetFullscreenDisplayModes = {
|
|
video_getFullscreenDisplayModes, "video_getFullscreenDisplayModes", "Use SDL_GetFullscreenDisplayModes function to get number of display modes", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetClosestDisplayModeCurrentResolution = {
|
|
video_getClosestDisplayModeCurrentResolution, "video_getClosestDisplayModeCurrentResolution", "Use function to get closes match to requested display mode for current resolution", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetClosestDisplayModeRandomResolution = {
|
|
video_getClosestDisplayModeRandomResolution, "video_getClosestDisplayModeRandomResolution", "Use function to get closes match to requested display mode for random resolution", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetWindowDisplayMode = {
|
|
video_getWindowDisplayMode, "video_getWindowDisplayMode", "Get window display mode", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetWindowDisplayModeNegative = {
|
|
video_getWindowDisplayModeNegative, "video_getWindowDisplayModeNegative", "Get window display mode with invalid input", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetSetWindowGrab = {
|
|
video_getSetWindowGrab, "video_getSetWindowGrab", "Checks input grab positive and negative cases", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetWindowID = {
|
|
video_getWindowId, "video_getWindowId", "Checks SDL_GetWindowID and SDL_GetWindowFromID", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetWindowPixelFormat = {
|
|
video_getWindowPixelFormat, "video_getWindowPixelFormat", "Checks SDL_GetWindowPixelFormat", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetSetWindowPosition = {
|
|
video_getSetWindowPosition, "video_getSetWindowPosition", "Checks SDL_GetWindowPosition and SDL_SetWindowPosition positive and negative cases", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetSetWindowSize = {
|
|
video_getSetWindowSize, "video_getSetWindowSize", "Checks SDL_GetWindowSize and SDL_SetWindowSize positive and negative cases", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetSetWindowMinimumSize = {
|
|
video_getSetWindowMinimumSize, "video_getSetWindowMinimumSize", "Checks SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize positive and negative cases", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetSetWindowMaximumSize = {
|
|
video_getSetWindowMaximumSize, "video_getSetWindowMaximumSize", "Checks SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize positive and negative cases", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetSetWindowData = {
|
|
video_getSetWindowData, "video_getSetWindowData", "Checks SDL_SetWindowData and SDL_GetWindowData positive and negative cases", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestSetWindowCenteredOnDisplay = {
|
|
video_setWindowCenteredOnDisplay, "video_setWindowCenteredOnDisplay", "Checks using SDL_WINDOWPOS_CENTERED_DISPLAY centers the window on a display", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetSetWindowState = {
|
|
video_getSetWindowState, "video_getSetWindowState", "Checks transitioning between windowed, minimized, maximized, and fullscreen states", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestCreateMinimized = {
|
|
video_createMinimized, "video_createMinimized", "Checks window state for windows created minimized", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestCreateMaximized = {
|
|
video_createMaximized, "video_createMaximized", "Checks window state for windows created maximized", TEST_ENABLED
|
|
};
|
|
|
|
static const SDLTest_TestCaseReference videoTestGetWindowSurface = {
|
|
video_getWindowSurface, "video_getWindowSurface", "Checks window surface functionality", TEST_ENABLED
|
|
};
|
|
|
|
/* Sequence of Video test cases */
|
|
static const SDLTest_TestCaseReference *videoTests[] = {
|
|
&videoTestEnableDisableScreensaver,
|
|
&videoTestCreateWindowVariousSizes,
|
|
&videoTestCreateWindowVariousFlags,
|
|
&videoTestGetWindowFlags,
|
|
&videoTestGetFullscreenDisplayModes,
|
|
&videoTestGetClosestDisplayModeCurrentResolution,
|
|
&videoTestGetClosestDisplayModeRandomResolution,
|
|
&videoTestGetWindowDisplayMode,
|
|
&videoTestGetWindowDisplayModeNegative,
|
|
&videoTestGetSetWindowGrab,
|
|
&videoTestGetWindowID,
|
|
&videoTestGetWindowPixelFormat,
|
|
&videoTestGetSetWindowPosition,
|
|
&videoTestGetSetWindowSize,
|
|
&videoTestGetSetWindowMinimumSize,
|
|
&videoTestGetSetWindowMaximumSize,
|
|
&videoTestGetSetWindowData,
|
|
&videoTestSetWindowCenteredOnDisplay,
|
|
&videoTestGetSetWindowState,
|
|
&videoTestCreateMinimized,
|
|
&videoTestCreateMaximized,
|
|
&videoTestGetWindowSurface,
|
|
NULL
|
|
};
|
|
|
|
/* Video test suite (global) */
|
|
SDLTest_TestSuiteReference videoTestSuite = {
|
|
"Video",
|
|
NULL,
|
|
videoTests,
|
|
NULL
|
|
};
|