2015-06-21 15:33:46 +00:00
/**
* Video test suite
*/
# include <stdio.h>
# include <string.h>
/* Visual Studio 2008 doesn't have stdint.h */
# if defined(_MSC_VER) && _MSC_VER <= 1500
# define UINT8_MAX ~(Uint8)0
# define UINT16_MAX ~(Uint16)0
# define UINT32_MAX ~(Uint32)0
# define UINT64_MAX ~(Uint64)0
# else
# include <stdint.h>
# endif
# include "SDL.h"
# include "SDL_test.h"
/* Private helpers */
/*
* Create a test window
*/
SDL_Window * _createVideoSuiteTestWindow ( const char * title )
{
2022-11-30 20:51:59 +00:00
SDL_Window * window ;
int x , y , w , h ;
SDL_WindowFlags flags ;
2023-10-06 17:50:10 +00:00
SDL_bool needs_renderer = SDL_FALSE ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Standard window */
x = SDLTest_RandomIntegerInRange ( 1 , 100 ) ;
y = SDLTest_RandomIntegerInRange ( 1 , 100 ) ;
w = SDLTest_RandomIntegerInRange ( 320 , 1024 ) ;
h = SDLTest_RandomIntegerInRange ( 320 , 768 ) ;
flags = SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
window = SDL_CreateWindow ( title , x , y , w , h , flags ) ;
SDLTest_AssertPass ( " Call to SDL_CreateWindow('Title',%d,%d,%d,%d,%d) " , x , y , w , h , flags ) ;
SDLTest_AssertCheck ( window ! = NULL , " Validate that returned window struct is not NULL " ) ;
2015-06-21 15:33:46 +00:00
2023-10-06 17:50:10 +00:00
/* 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 = SDL_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_getenv ( " XDG_SESSION_TYPE " ) ;
if ( session_type & & SDL_strcasecmp ( session_type , " wayland " ) = = 0 ) {
needs_renderer = SDL_TRUE ;
}
}
if ( needs_renderer ) {
SDL_Renderer * renderer = SDL_CreateRenderer ( window , - 1 , 0 ) ;
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 " ) ;
}
}
2022-11-30 20:51:59 +00:00
return window ;
2015-06-21 15:33:46 +00:00
}
/*
* Destroy test window
*/
void _destroyVideoSuiteTestWindow ( SDL_Window * window )
{
2023-11-10 14:30:56 +00:00
if ( window ) {
2022-11-30 20:51:59 +00:00
SDL_DestroyWindow ( window ) ;
window = NULL ;
SDLTest_AssertPass ( " Call to SDL_DestroyWindow() " ) ;
}
2015-06-21 15:33:46 +00:00
}
/* Test case functions */
/**
* @ brief Enable and disable screensaver while checking state
*/
2022-11-30 20:51:59 +00:00
int video_enableDisableScreensaver ( void * arg )
2015-06-21 15:33:46 +00:00
{
SDL_bool initialResult ;
SDL_bool result ;
/* Get current state and proceed according to current state */
initialResult = SDL_IsScreenSaverEnabled ( ) ;
SDLTest_AssertPass ( " Call to SDL_IsScreenSaverEnabled() " ) ;
if ( initialResult = = SDL_TRUE ) {
2022-11-30 20:51:59 +00:00
/* Currently enabled: disable first, then enable again */
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Disable screensaver and check */
SDL_DisableScreenSaver ( ) ;
SDLTest_AssertPass ( " Call to SDL_DisableScreenSaver() " ) ;
result = SDL_IsScreenSaverEnabled ( ) ;
SDLTest_AssertPass ( " Call to SDL_IsScreenSaverEnabled() " ) ;
SDLTest_AssertCheck ( result = = SDL_FALSE , " Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i " , SDL_FALSE , result ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Enable screensaver and check */
SDL_EnableScreenSaver ( ) ;
SDLTest_AssertPass ( " Call to SDL_EnableScreenSaver() " ) ;
result = SDL_IsScreenSaverEnabled ( ) ;
SDLTest_AssertPass ( " Call to SDL_IsScreenSaverEnabled() " ) ;
SDLTest_AssertCheck ( result = = SDL_TRUE , " Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i " , SDL_TRUE , result ) ;
2015-06-21 15:33:46 +00:00
} else {
2022-11-30 20:51:59 +00:00
/* Currently disabled: enable first, then disable again */
/* Enable screensaver and check */
SDL_EnableScreenSaver ( ) ;
SDLTest_AssertPass ( " Call to SDL_EnableScreenSaver() " ) ;
result = SDL_IsScreenSaverEnabled ( ) ;
SDLTest_AssertPass ( " Call to SDL_IsScreenSaverEnabled() " ) ;
SDLTest_AssertCheck ( result = = SDL_TRUE , " Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i " , SDL_TRUE , result ) ;
/* Disable screensaver and check */
SDL_DisableScreenSaver ( ) ;
SDLTest_AssertPass ( " Call to SDL_DisableScreenSaver() " ) ;
result = SDL_IsScreenSaverEnabled ( ) ;
SDLTest_AssertPass ( " Call to SDL_IsScreenSaverEnabled() " ) ;
SDLTest_AssertCheck ( result = = SDL_FALSE , " Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i " , SDL_FALSE , result ) ;
2015-06-21 15:33:46 +00:00
}
return TEST_COMPLETED ;
}
/**
* @ brief Tests the functionality of the SDL_CreateWindow function using different positions
*/
2022-11-30 20:51:59 +00:00
int video_createWindowVariousPositions ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
SDL_Window * window ;
const char * title = " video_createWindowVariousPositions Test Window " ;
int x , y , w , h ;
int xVariation , yVariation ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
for ( xVariation = 0 ; xVariation < 6 ; xVariation + + ) {
for ( yVariation = 0 ; yVariation < 6 ; yVariation + + ) {
switch ( xVariation ) {
default :
case 0 :
/* Zero X Position */
x = 0 ;
break ;
case 1 :
/* Random X position inside screen */
x = SDLTest_RandomIntegerInRange ( 1 , 100 ) ;
break ;
case 2 :
/* Random X position outside screen (positive) */
x = SDLTest_RandomIntegerInRange ( 10000 , 11000 ) ;
break ;
case 3 :
/* Random X position outside screen (negative) */
x = SDLTest_RandomIntegerInRange ( - 1000 , - 100 ) ;
break ;
case 4 :
/* Centered X position */
x = SDL_WINDOWPOS_CENTERED ;
break ;
case 5 :
/* Undefined X position */
x = SDL_WINDOWPOS_UNDEFINED ;
break ;
}
switch ( yVariation ) {
default :
case 0 :
/* Zero X Position */
y = 0 ;
break ;
case 1 :
/* Random X position inside screen */
y = SDLTest_RandomIntegerInRange ( 1 , 100 ) ;
break ;
case 2 :
/* Random X position outside screen (positive) */
y = SDLTest_RandomIntegerInRange ( 10000 , 11000 ) ;
break ;
case 3 :
/* Random Y position outside screen (negative) */
y = SDLTest_RandomIntegerInRange ( - 1000 , - 100 ) ;
break ;
case 4 :
/* Centered Y position */
y = SDL_WINDOWPOS_CENTERED ;
break ;
case 5 :
/* Undefined Y position */
y = SDL_WINDOWPOS_UNDEFINED ;
break ;
}
w = SDLTest_RandomIntegerInRange ( 32 , 96 ) ;
h = SDLTest_RandomIntegerInRange ( 32 , 96 ) ;
window = SDL_CreateWindow ( title , x , y , w , h , SDL_WINDOW_SHOWN ) ;
SDLTest_AssertPass ( " Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN) " , x , y , w , h ) ;
SDLTest_AssertCheck ( window ! = NULL , " Validate that returned window struct is not NULL " ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
}
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests the functionality of the SDL_CreateWindow function using different sizes
*/
2022-11-30 20:51:59 +00:00
int video_createWindowVariousSizes ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
SDL_Window * window ;
const char * title = " video_createWindowVariousSizes Test Window " ;
int x , y , w , h ;
int wVariation , hVariation ;
x = SDLTest_RandomIntegerInRange ( 1 , 100 ) ;
y = SDLTest_RandomIntegerInRange ( 1 , 100 ) ;
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 , x , y , w , h , SDL_WINDOW_SHOWN ) ;
SDLTest_AssertPass ( " Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN) " , x , y , w , h ) ;
SDLTest_AssertCheck ( window ! = NULL , " Validate that returned window struct is not NULL " ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
}
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests the functionality of the SDL_CreateWindow function using different flags
*/
2022-11-30 20:51:59 +00:00
int video_createWindowVariousFlags ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
SDL_Window * window ;
const char * title = " video_createWindowVariousFlags Test Window " ;
int x , y , w , h ;
int fVariation ;
SDL_WindowFlags flags ;
/* Standard window */
x = SDLTest_RandomIntegerInRange ( 1 , 100 ) ;
y = SDLTest_RandomIntegerInRange ( 1 , 100 ) ;
w = SDLTest_RandomIntegerInRange ( 320 , 1024 ) ;
h = SDLTest_RandomIntegerInRange ( 320 , 768 ) ;
for ( fVariation = 0 ; fVariation < 14 ; fVariation + + ) {
switch ( fVariation ) {
default :
case 0 :
flags = SDL_WINDOW_FULLSCREEN ;
/* Skip - blanks screen; comment out next line to run test */
continue ;
break ;
case 1 :
flags = SDL_WINDOW_FULLSCREEN_DESKTOP ;
/* Skip - blanks screen; comment out next line to run test */
continue ;
break ;
case 2 :
flags = SDL_WINDOW_OPENGL ;
2023-09-29 16:55:09 +00:00
/* Skip - not every video driver supports OpenGL; comment out next line to run test */
continue ;
2022-11-30 20:51:59 +00:00
break ;
case 3 :
flags = SDL_WINDOW_SHOWN ;
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_FOREIGN ;
break ;
case 13 :
flags = SDL_WINDOW_KEYBOARD_GRABBED ;
break ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
window = SDL_CreateWindow ( title , x , y , w , h , flags ) ;
SDLTest_AssertPass ( " Call to SDL_CreateWindow('Title',%d,%d,%d,%d,%d) " , x , y , w , h , flags ) ;
SDLTest_AssertCheck ( window ! = NULL , " Validate that returned window struct is not NULL " ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests the functionality of the SDL_GetWindowFlags function
*/
2022-11-30 20:51:59 +00:00
int video_getWindowFlags ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
SDL_Window * window ;
const char * title = " video_getWindowFlags Test Window " ;
SDL_WindowFlags flags ;
Uint32 actualFlags ;
/* Reliable flag set always set in test window */
flags = SDL_WINDOW_SHOWN ;
/* 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 %d set, got: % " SDL_PRIu32 , flags , actualFlags ) ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests the functionality of the SDL_GetNumDisplayModes function
*/
2022-11-30 20:51:59 +00:00
int video_getNumDisplayModes ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
int result ;
int displayNum ;
int i ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get number of displays */
displayNum = SDL_GetNumVideoDisplays ( ) ;
SDLTest_AssertPass ( " Call to SDL_GetNumVideoDisplays() " ) ;
/* Make call for each display */
for ( i = 0 ; i < displayNum ; i + + ) {
result = SDL_GetNumDisplayModes ( i ) ;
SDLTest_AssertPass ( " Call to SDL_GetNumDisplayModes(%d) " , i ) ;
SDLTest_AssertCheck ( result > = 1 , " Validate returned value from function; expected: >=1; got: %d " , result ) ;
}
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests negative call to SDL_GetNumDisplayModes function
*/
2022-11-30 20:51:59 +00:00
int video_getNumDisplayModesNegative ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
int result ;
int displayNum ;
int displayIndex ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get number of displays */
displayNum = SDL_GetNumVideoDisplays ( ) ;
SDLTest_AssertPass ( " Call to SDL_GetNumVideoDisplays() " ) ;
/* Invalid boundary values */
displayIndex = SDLTest_RandomSint32BoundaryValue ( 0 , displayNum , SDL_FALSE ) ;
result = SDL_GetNumDisplayModes ( displayIndex ) ;
SDLTest_AssertPass ( " Call to SDL_GetNumDisplayModes(%d=out-of-bounds/boundary) " , displayIndex ) ;
SDLTest_AssertCheck ( result < 0 , " Validate returned value from function; expected: <0; got: %d " , result ) ;
/* Large (out-of-bounds) display index */
displayIndex = SDLTest_RandomIntegerInRange ( - 2000 , - 1000 ) ;
result = SDL_GetNumDisplayModes ( displayIndex ) ;
SDLTest_AssertPass ( " Call to SDL_GetNumDisplayModes(%d=out-of-bounds/large negative) " , displayIndex ) ;
SDLTest_AssertCheck ( result < 0 , " Validate returned value from function; expected: <0; got: %d " , result ) ;
displayIndex = SDLTest_RandomIntegerInRange ( 1000 , 2000 ) ;
result = SDL_GetNumDisplayModes ( displayIndex ) ;
SDLTest_AssertPass ( " Call to SDL_GetNumDisplayModes(%d=out-of-bounds/large positive) " , displayIndex ) ;
SDLTest_AssertCheck ( result < 0 , " Validate returned value from function; expected: <0; got: %d " , result ) ;
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests the functionality of the SDL_GetClosestDisplayMode function against current resolution
*/
2022-11-30 20:51:59 +00:00
int video_getClosestDisplayModeCurrentResolution ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
int result ;
SDL_DisplayMode current ;
SDL_DisplayMode target ;
SDL_DisplayMode closest ;
SDL_DisplayMode * dResult ;
int displayNum ;
int i ;
int variation ;
/* Get number of displays */
displayNum = SDL_GetNumVideoDisplays ( ) ;
SDLTest_AssertPass ( " Call to SDL_GetNumVideoDisplays() " ) ;
/* Make calls for each display */
for ( i = 0 ; i < displayNum ; i + + ) {
SDLTest_Log ( " Testing against display: %d " , i ) ;
/* Get first display mode to get a sane resolution; this should always work */
result = SDL_GetDisplayMode ( i , 0 , & current ) ;
SDLTest_AssertPass ( " Call to SDL_GetDisplayMode() " ) ;
SDLTest_AssertCheck ( result = = 0 , " Verify return value, expected: 0, got: %d " , result ) ;
if ( result ! = 0 ) {
return TEST_ABORTED ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Set the desired resolution equals to current resolution */
target . w = current . w ;
target . h = current . h ;
for ( variation = 0 ; variation < 8 ; variation + + ) {
/* Vary constraints on other query parameters */
target . format = ( variation & 1 ) ? current . format : 0 ;
target . refresh_rate = ( variation & 2 ) ? current . refresh_rate : 0 ;
target . driverdata = ( variation & 4 ) ? current . driverdata : 0 ;
/* Make call */
dResult = SDL_GetClosestDisplayMode ( i , & target , & closest ) ;
SDLTest_AssertPass ( " Call to SDL_GetClosestDisplayMode(target=current/variation%d) " , variation ) ;
2022-12-01 21:07:03 +00:00
SDLTest_Assert ( dResult ! = NULL , " Verify returned value is not NULL " ) ;
2022-11-30 20:51:59 +00:00
/* Check that one gets the current resolution back again */
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 ) ;
2022-12-01 21:07:03 +00:00
/* NOLINTBEGIN(clang-analyzer-core.NullDereference): Checked earlier for NULL */
2022-11-30 20:51:59 +00:00
SDLTest_AssertCheck ( closest . w = = dResult - > w , " Verify return value matches assigned value; expected: %d, got: %d " , closest . w , dResult - > w ) ;
SDLTest_AssertCheck ( closest . h = = dResult - > h , " Verify return value matches assigned value; expected: %d, got: %d " , closest . h , dResult - > h ) ;
2022-12-01 21:07:03 +00:00
/* NOLINTEND(clang-analyzer-core.NullDereference) */
2022-11-30 20:51:59 +00:00
}
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests the functionality of the SDL_GetClosestDisplayMode function against random resolution
*/
2022-11-30 20:51:59 +00:00
int video_getClosestDisplayModeRandomResolution ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
SDL_DisplayMode target ;
SDL_DisplayMode closest ;
int displayNum ;
int i ;
int variation ;
/* Get number of displays */
displayNum = SDL_GetNumVideoDisplays ( ) ;
SDLTest_AssertPass ( " Call to SDL_GetNumVideoDisplays() " ) ;
/* Make calls for each display */
for ( i = 0 ; i < displayNum ; i + + ) {
SDLTest_Log ( " Testing against display: %d " , i ) ;
for ( variation = 0 ; variation < 16 ; variation + + ) {
/* Set random constraints */
target . w = ( variation & 1 ) ? SDLTest_RandomIntegerInRange ( 1 , 4096 ) : 0 ;
target . h = ( variation & 2 ) ? SDLTest_RandomIntegerInRange ( 1 , 4096 ) : 0 ;
target . format = ( variation & 4 ) ? SDLTest_RandomIntegerInRange ( 1 , 10 ) : 0 ;
target . refresh_rate = ( variation & 8 ) ? SDLTest_RandomIntegerInRange ( 25 , 120 ) : 0 ;
target . driverdata = 0 ;
/* Make call; may or may not find anything, so don't validate any further */
SDL_GetClosestDisplayMode ( i , & target , & closest ) ;
SDLTest_AssertPass ( " Call to SDL_GetClosestDisplayMode(target=random/variation%d) " , variation ) ;
}
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_GetWindowBrightness
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowBrightness
2015-06-21 15:33:46 +00:00
*/
int
video_getWindowBrightness ( void * arg )
{
SDL_Window * window ;
const char * title = " video_getWindowBrightness Test Window " ;
float result ;
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
if ( window ! = NULL ) {
result = SDL_GetWindowBrightness ( window ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowBrightness() " ) ;
SDLTest_AssertCheck ( result > = 0.0 & & result < = 1.0 , " Validate range of result value; expected: [0.0, 1.0], got: %f " , result ) ;
}
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
return TEST_COMPLETED ;
}
/**
* @ brief Tests call to SDL_GetWindowBrightness with invalid input
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowBrightness
2015-06-21 15:33:46 +00:00
*/
int
video_getWindowBrightnessNegative ( void * arg )
{
const char * invalidWindowError = " Invalid window " ;
char * lastError ;
float result ;
/* Call against invalid window */
result = SDL_GetWindowBrightness ( NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowBrightness(window=NULL) " ) ;
SDLTest_AssertCheck ( result = = 1.0 , " Validate result value; expected: 1.0, got: %f " , result ) ;
lastError = ( char * ) 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 ) ;
}
return TEST_COMPLETED ;
}
/**
* @ brief Tests call to SDL_GetWindowDisplayMode
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowDisplayMode
2015-06-21 15:33:46 +00:00
*/
2022-11-30 20:51:59 +00:00
int video_getWindowDisplayMode ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
SDL_Window * window ;
const char * title = " video_getWindowDisplayMode Test Window " ;
SDL_DisplayMode mode ;
int result ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Invalidate part of the mode content so we can check values later */
mode . w = - 1 ;
mode . h = - 1 ;
mode . refresh_rate = - 1 ;
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( window ) {
2022-11-30 20:51:59 +00:00
result = SDL_GetWindowDisplayMode ( window , & mode ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowDisplayMode() " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
SDLTest_AssertCheck ( mode . w > 0 , " Validate mode.w content; expected: >0, got: %d " , mode . w ) ;
SDLTest_AssertCheck ( mode . h > 0 , " Validate mode.h content; expected: >0, got: %d " , mode . h ) ;
SDLTest_AssertCheck ( mode . refresh_rate > 0 , " Validate mode.refresh_rate content; expected: >0, got: %d " , mode . refresh_rate ) ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/* Helper function that checks for an 'Invalid window' error */
void _checkInvalidWindowError ( )
{
2022-11-30 20:51:59 +00:00
const char * invalidWindowError = " Invalid window " ;
char * lastError ;
lastError = ( char * ) 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() " ) ;
}
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_GetWindowDisplayMode with invalid input
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowDisplayMode
2015-06-21 15:33:46 +00:00
*/
2022-11-30 20:51:59 +00:00
int video_getWindowDisplayModeNegative ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
const char * expectedError = " Parameter 'mode' is invalid " ;
char * lastError ;
SDL_Window * window ;
const char * title = " video_getWindowDisplayModeNegative Test Window " ;
SDL_DisplayMode mode ;
int result ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
if ( window ! = NULL ) {
result = SDL_GetWindowDisplayMode ( window , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowDisplayMode(...,mode=NULL) " ) ;
SDLTest_AssertCheck ( result = = - 1 , " Validate result value; expected: -1, got: %d " , result ) ;
lastError = ( char * ) SDL_GetError ( ) ;
SDLTest_AssertPass ( " SDL_GetError() " ) ;
SDLTest_AssertCheck ( lastError ! = NULL , " Verify error message is not NULL " ) ;
if ( lastError ! = NULL ) {
SDLTest_AssertCheck ( SDL_strcmp ( lastError , expectedError ) = = 0 ,
" SDL_GetError(): expected message '%s', was message: '%s' " ,
expectedError ,
lastError ) ;
}
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Call against invalid window */
result = SDL_GetWindowDisplayMode ( NULL , & mode ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowDisplayMode(window=NULL,...) " ) ;
SDLTest_AssertCheck ( result = = - 1 , " Validate result value; expected: -1, got: %d " , result ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_GetWindowGammaRamp
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowGammaRamp
2015-06-21 15:33:46 +00:00
*/
int
video_getWindowGammaRamp ( void * arg )
{
SDL_Window * window ;
const char * title = " video_getWindowGammaRamp Test Window " ;
Uint16 red [ 256 ] ;
Uint16 green [ 256 ] ;
Uint16 blue [ 256 ] ;
int result ;
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) return TEST_ABORTED ;
2015-06-21 15:33:46 +00:00
/* Retrieve no channel */
result = SDL_GetWindowGammaRamp ( window , NULL , NULL , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(all NULL) " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
/* Retrieve single channel */
result = SDL_GetWindowGammaRamp ( window , red , NULL , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(r) " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
result = SDL_GetWindowGammaRamp ( window , NULL , green , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(g) " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
result = SDL_GetWindowGammaRamp ( window , NULL , NULL , blue ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(b) " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
/* Retrieve two channels */
result = SDL_GetWindowGammaRamp ( window , red , green , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(r, g) " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
result = SDL_GetWindowGammaRamp ( window , NULL , green , blue ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(g,b) " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
result = SDL_GetWindowGammaRamp ( window , red , NULL , blue ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(r,b) " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
/* Retrieve all channels */
result = SDL_GetWindowGammaRamp ( window , red , green , blue ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(r,g,b) " ) ;
SDLTest_AssertCheck ( result = = 0 , " Validate result value; expected: 0, got: %d " , result ) ;
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
return TEST_COMPLETED ;
}
/**
* @ brief Tests call to SDL_GetWindowGammaRamp with invalid input
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowGammaRamp
2015-06-21 15:33:46 +00:00
*/
int
video_getWindowGammaRampNegative ( void * arg )
{
Uint16 red [ 256 ] ;
Uint16 green [ 256 ] ;
Uint16 blue [ 256 ] ;
int result ;
SDL_ClearError ( ) ;
SDLTest_AssertPass ( " Call to SDL_ClearError() " ) ;
/* Call against invalid window */
result = SDL_GetWindowGammaRamp ( NULL , red , green , blue ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGammaRamp(window=NULL,r,g,b) " ) ;
SDLTest_AssertCheck ( result = = - 1 , " Validate result value; expected: -1, got: %i " , result ) ;
_checkInvalidWindowError ( ) ;
return TEST_COMPLETED ;
}
2021-01-27 01:16:17 +00:00
/* Helper for setting and checking the window mouse grab state */
2022-11-30 20:51:59 +00:00
void _setAndCheckWindowMouseGrabState ( SDL_Window * window , SDL_bool desiredState )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
SDL_bool currentState ;
/* Set state */
SDL_SetWindowMouseGrab ( window , desiredState ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowMouseGrab(%s) " , ( desiredState = = SDL_FALSE ) ? " SDL_FALSE " : " SDL_TRUE " ) ;
/* Get and check state */
currentState = SDL_GetWindowMouseGrab ( window ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowMouseGrab() " ) ;
2021-01-27 01:16:17 +00:00
SDLTest_AssertCheck (
2022-11-30 20:51:59 +00:00
currentState = = desiredState ,
" Validate returned state; expected: %s, got: %s " ,
( desiredState = = SDL_FALSE ) ? " SDL_FALSE " : " SDL_TRUE " ,
( currentState = = SDL_FALSE ) ? " SDL_FALSE " : " SDL_TRUE " ) ;
if ( desiredState ) {
SDLTest_AssertCheck (
SDL_GetGrabbedWindow ( ) = = window ,
" Grabbed window should be to our window " ) ;
SDLTest_AssertCheck (
SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_TRUE " ) ;
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 " ) ;
}
2021-01-27 01:16:17 +00:00
}
/* Helper for setting and checking the window keyboard grab state */
2022-11-30 20:51:59 +00:00
void _setAndCheckWindowKeyboardGrabState ( SDL_Window * window , SDL_bool desiredState )
2021-01-27 01:16:17 +00:00
{
2022-11-30 20:51:59 +00:00
SDL_bool currentState ;
/* Set state */
SDL_SetWindowKeyboardGrab ( window , desiredState ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowKeyboardGrab(%s) " , ( desiredState = = SDL_FALSE ) ? " SDL_FALSE " : " SDL_TRUE " ) ;
/* Get and check state */
currentState = SDL_GetWindowKeyboardGrab ( window ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowKeyboardGrab() " ) ;
2021-01-27 01:16:17 +00:00
SDLTest_AssertCheck (
2022-11-30 20:51:59 +00:00
currentState = = desiredState ,
" Validate returned state; expected: %s, got: %s " ,
( desiredState = = SDL_FALSE ) ? " SDL_FALSE " : " SDL_TRUE " ,
( currentState = = SDL_FALSE ) ? " SDL_FALSE " : " SDL_TRUE " ) ;
if ( desiredState ) {
SDLTest_AssertCheck (
SDL_GetGrabbedWindow ( ) = = window ,
" Grabbed window should be set to our window " ) ;
SDLTest_AssertCheck (
SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_TRUE " ) ;
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 " ) ;
}
2015-06-21 15:33:46 +00:00
}
/**
2021-01-27 01:16:17 +00:00
* @ brief Tests keyboard and mouse grab support
2015-06-21 15:33:46 +00:00
*
2021-04-01 16:15:28 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowGrab
* @ sa http : //wiki.libsdl.org/SDL_SetWindowGrab
2015-06-21 15:33:46 +00:00
*/
2022-11-30 20:51:59 +00:00
int video_getSetWindowGrab ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
const char * title = " video_getSetWindowGrab Test Window " ;
SDL_Window * window ;
SDL_bool originalMouseState , originalKeyboardState ;
2023-10-06 17:50:10 +00:00
SDL_bool hasFocusGained = SDL_FALSE ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) {
2022-11-30 20:51:59 +00:00
return TEST_ABORTED ;
}
2015-06-21 15:33:46 +00:00
2023-10-06 17:50:10 +00:00
/* 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 ) ;
{
SDL_Event evt ;
SDL_zero ( evt ) ;
while ( SDL_PollEvent ( & evt ) ) {
if ( evt . type = = SDL_WINDOWEVENT ) {
if ( evt . window . event = = SDL_WINDOWEVENT_FOCUS_GAINED ) {
hasFocusGained = SDL_TRUE ;
}
}
}
}
SDLTest_AssertCheck ( hasFocusGained = = SDL_TRUE , " Expected window with focus " ) ;
2022-11-30 20:51:59 +00:00
/* 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 , SDL_FALSE ) ;
_setAndCheckWindowMouseGrabState ( window , SDL_FALSE ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab should return SDL_FALSE " ) ;
SDLTest_AssertCheck ( SDL_GetGrabbedWindow ( ) = = NULL ,
" Expected NULL grabbed window " ) ;
/* F --> F */
_setAndCheckWindowMouseGrabState ( window , SDL_FALSE ) ;
_setAndCheckWindowKeyboardGrabState ( window , SDL_FALSE ) ;
SDLTest_AssertCheck ( SDL_GetGrabbedWindow ( ) = = NULL ,
" Expected NULL grabbed window " ) ;
/* F --> T */
_setAndCheckWindowMouseGrabState ( window , SDL_TRUE ) ;
_setAndCheckWindowKeyboardGrabState ( window , SDL_TRUE ) ;
SDLTest_AssertCheck ( SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_TRUE " ) ;
/* T --> T */
_setAndCheckWindowKeyboardGrabState ( window , SDL_TRUE ) ;
_setAndCheckWindowMouseGrabState ( window , SDL_TRUE ) ;
SDLTest_AssertCheck ( SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_TRUE " ) ;
/* M: T --> F */
/* K: T --> T */
_setAndCheckWindowKeyboardGrabState ( window , SDL_TRUE ) ;
_setAndCheckWindowMouseGrabState ( window , SDL_FALSE ) ;
SDLTest_AssertCheck ( SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_TRUE " ) ;
/* M: F --> T */
/* K: T --> F */
_setAndCheckWindowMouseGrabState ( window , SDL_TRUE ) ;
_setAndCheckWindowKeyboardGrabState ( window , SDL_FALSE ) ;
SDLTest_AssertCheck ( SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_TRUE " ) ;
/* M: T --> F */
/* K: F --> F */
_setAndCheckWindowMouseGrabState ( window , SDL_FALSE ) ;
_setAndCheckWindowKeyboardGrabState ( window , SDL_FALSE ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_FALSE " ) ;
SDLTest_AssertCheck ( SDL_GetGrabbedWindow ( ) = = NULL ,
" Expected NULL grabbed window " ) ;
/* Using the older SDL_SetWindowGrab API should only grab mouse by default */
SDL_SetWindowGrab ( window , SDL_TRUE ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowGrab(SDL_TRUE) " ) ;
SDLTest_AssertCheck ( SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_TRUE " ) ;
SDLTest_AssertCheck ( SDL_GetWindowMouseGrab ( window ) ,
" SDL_GetWindowMouseGrab() should return SDL_TRUE " ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowKeyboardGrab ( window ) ,
" SDL_GetWindowKeyboardGrab() should return SDL_FALSE " ) ;
SDL_SetWindowGrab ( window , SDL_FALSE ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_FALSE " ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowMouseGrab ( window ) ,
" SDL_GetWindowMouseGrab() should return SDL_FALSE " ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowKeyboardGrab ( window ) ,
" SDL_GetWindowKeyboardGrab() should return SDL_FALSE " ) ;
/* Now test with SDL_HINT_GRAB_KEYBOARD set. We should get keyboard grab now. */
SDL_SetHint ( SDL_HINT_GRAB_KEYBOARD , " 1 " ) ;
SDL_SetWindowGrab ( window , SDL_TRUE ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowGrab(SDL_TRUE) " ) ;
SDLTest_AssertCheck ( SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_TRUE " ) ;
SDLTest_AssertCheck ( SDL_GetWindowMouseGrab ( window ) ,
" SDL_GetWindowMouseGrab() should return SDL_TRUE " ) ;
SDLTest_AssertCheck ( SDL_GetWindowKeyboardGrab ( window ) ,
" SDL_GetWindowKeyboardGrab() should return SDL_TRUE " ) ;
SDL_SetWindowGrab ( window , SDL_FALSE ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowGrab ( window ) ,
" SDL_GetWindowGrab() should return SDL_FALSE " ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowMouseGrab ( window ) ,
" SDL_GetWindowMouseGrab() should return SDL_FALSE " ) ;
SDLTest_AssertCheck ( ! SDL_GetWindowKeyboardGrab ( window ) ,
" SDL_GetWindowKeyboardGrab() should return SDL_FALSE " ) ;
/* Negative tests */
SDL_GetWindowGrab ( NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowGrab(window=NULL) " ) ;
_checkInvalidWindowError ( ) ;
SDL_GetWindowKeyboardGrab ( NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowKeyboardGrab(window=NULL) " ) ;
_checkInvalidWindowError ( ) ;
SDL_SetWindowGrab ( NULL , SDL_FALSE ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE) " ) ;
_checkInvalidWindowError ( ) ;
SDL_SetWindowKeyboardGrab ( NULL , SDL_FALSE ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowKeyboardGrab(window=NULL,SDL_FALSE) " ) ;
_checkInvalidWindowError ( ) ;
SDL_SetWindowGrab ( NULL , SDL_TRUE ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowGrab(window=NULL,SDL_TRUE) " ) ;
_checkInvalidWindowError ( ) ;
SDL_SetWindowKeyboardGrab ( NULL , SDL_TRUE ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowKeyboardGrab(window=NULL,SDL_TRUE) " ) ;
_checkInvalidWindowError ( ) ;
/* Restore state */
_setAndCheckWindowMouseGrabState ( window , originalMouseState ) ;
_setAndCheckWindowKeyboardGrabState ( window , originalKeyboardState ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_GetWindowID and SDL_GetWindowFromID
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowID
* @ sa http : //wiki.libsdl.org/SDL_SetWindowFromID
2015-06-21 15:33:46 +00:00
*/
2022-11-30 20:51:59 +00:00
int video_getWindowId ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
const char * title = " video_getWindowId Test Window " ;
SDL_Window * window ;
SDL_Window * result ;
Uint32 id , randomId ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) {
2022-11-30 20:51:59 +00:00
return TEST_ABORTED ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get ID */
id = SDL_GetWindowID ( window ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowID() " ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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 " ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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 ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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) " ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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 " ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Negative test */
SDL_ClearError ( ) ;
SDLTest_AssertPass ( " Call to SDL_ClearError() " ) ;
id = SDL_GetWindowID ( NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowID(window=NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_GetWindowPixelFormat
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowPixelFormat
2015-06-21 15:33:46 +00:00
*/
2022-11-30 20:51:59 +00:00
int video_getWindowPixelFormat ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
const char * title = " video_getWindowPixelFormat Test Window " ;
SDL_Window * window ;
Uint32 format ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) {
2022-11-30 20:51:59 +00:00
return TEST_ABORTED ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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: != %d, got: % " SDL_PRIu32 , SDL_PIXELFORMAT_UNKNOWN , format ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Negative test */
SDL_ClearError ( ) ;
SDLTest_AssertPass ( " Call to SDL_ClearError() " ) ;
format = SDL_GetWindowPixelFormat ( NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowPixelFormat(window=NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
2023-03-25 09:24:38 +00:00
static SDL_bool getPositionFromEvent ( int * x , int * y )
{
SDL_bool ret = SDL_FALSE ;
SDL_Event evt ;
SDL_zero ( evt ) ;
while ( SDL_PollEvent ( & evt ) ) {
if ( evt . type = = SDL_WINDOWEVENT & & evt . window . event = = SDL_WINDOWEVENT_MOVED ) {
* x = evt . window . data1 ;
* y = evt . window . data2 ;
ret = SDL_TRUE ;
}
}
return ret ;
}
static SDL_bool getSizeFromEvent ( int * w , int * h )
{
SDL_bool ret = SDL_FALSE ;
SDL_Event evt ;
SDL_zero ( evt ) ;
while ( SDL_PollEvent ( & evt ) ) {
if ( evt . type = = SDL_WINDOWEVENT & & evt . window . event = = SDL_WINDOWEVENT_RESIZED ) {
* w = evt . window . data1 ;
* h = evt . window . data2 ;
ret = SDL_TRUE ;
}
}
return ret ;
}
2015-06-21 15:33:46 +00:00
/**
* @ brief Tests call to SDL_GetWindowPosition and SDL_SetWindowPosition
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowPosition
* @ sa http : //wiki.libsdl.org/SDL_SetWindowPosition
2015-06-21 15:33:46 +00:00
*/
2022-11-30 20:51:59 +00:00
int video_getSetWindowPosition ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
const char * title = " video_getSetWindowPosition Test Window " ;
SDL_Window * window ;
2023-12-12 21:04:49 +00:00
int maxxVariation , maxyVariation ;
2022-11-30 20:51:59 +00:00
int xVariation , yVariation ;
int referenceX , referenceY ;
int currentX , currentY ;
int desiredX , desiredY ;
2023-12-12 21:04:49 +00:00
SDL_Rect display_bounds ;
if ( SDL_strcmp ( SDL_GetCurrentVideoDriver ( ) , " wayland " ) = = 0 ) {
2023-12-12 22:17:00 +00:00
SDLTest_Log ( " Skipping test: wayland does not support window positioning " ) ;
return TEST_SKIPPED ;
2023-12-12 21:04:49 +00:00
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) {
2022-11-30 20:51:59 +00:00
return TEST_ABORTED ;
2015-06-21 15:33:46 +00:00
}
2023-12-12 21:04:49 +00:00
if ( SDL_strcmp ( SDL_GetCurrentVideoDriver ( ) , " x11 " ) = = 0 ) {
2023-12-12 22:17:00 +00:00
/* The X11 server allows arbitrary window placement, but compositing
2023-12-12 21:04:49 +00:00
* window managers such as GNOME and KDE force windows to be within
* desktop bounds .
2023-12-12 22:17:00 +00:00
*/
maxxVariation = 2 ;
maxyVariation = 2 ;
2023-12-12 21:04:49 +00:00
2023-12-12 22:17:00 +00:00
SDL_GetDisplayUsableBounds ( SDL_GetWindowDisplayIndex ( window ) , & display_bounds ) ;
2023-12-12 21:04:49 +00:00
} else if ( SDL_strcmp ( SDL_GetCurrentVideoDriver ( ) , " cocoa " ) = = 0 ) {
2023-12-12 22:17:00 +00:00
/* Platform doesn't allow windows with negative Y desktop bounds */
maxxVariation = 4 ;
maxyVariation = 3 ;
2023-12-12 21:04:49 +00:00
2023-12-12 22:17:00 +00:00
SDL_GetDisplayUsableBounds ( SDL_GetWindowDisplayIndex ( window ) , & display_bounds ) ;
2023-12-12 21:04:49 +00:00
} else {
2023-12-12 22:17:00 +00:00
/* Platform allows windows to be placed out of bounds */
maxxVariation = 4 ;
maxyVariation = 4 ;
2023-12-12 21:04:49 +00:00
2023-12-12 22:17:00 +00:00
SDL_GetDisplayBounds ( SDL_GetWindowDisplayIndex ( window ) , & display_bounds ) ;
2023-12-12 21:04:49 +00:00
}
for ( xVariation = 0 ; xVariation < maxxVariation ; xVariation + + ) {
for ( yVariation = 0 ; yVariation < maxyVariation ; yVariation + + ) {
2022-11-30 20:51:59 +00:00
switch ( xVariation ) {
default :
case 0 :
2023-12-12 22:17:00 +00:00
/* Zero X Position */
desiredX = display_bounds . x > 0 ? display_bounds . x : 0 ;
break ;
2022-11-30 20:51:59 +00:00
case 1 :
2023-12-12 22:17:00 +00:00
/* Random X position inside screen */
desiredX = SDLTest_RandomIntegerInRange ( display_bounds . x + 1 , display_bounds . x + 100 ) ;
break ;
2022-11-30 20:51:59 +00:00
case 2 :
2023-12-12 22:17:00 +00:00
/* Random X position outside screen (positive) */
desiredX = SDLTest_RandomIntegerInRange ( 10000 , 11000 ) ;
break ;
2022-11-30 20:51:59 +00:00
case 3 :
2023-12-12 22:17:00 +00:00
/* Random X position outside screen (negative) */
desiredX = SDLTest_RandomIntegerInRange ( - 1000 , - 100 ) ;
break ;
2022-11-30 20:51:59 +00:00
}
switch ( yVariation ) {
default :
case 0 :
2023-12-12 22:17:00 +00:00
/* Zero Y Position */
desiredY = display_bounds . y > 0 ? display_bounds . y : 0 ;
break ;
2022-11-30 20:51:59 +00:00
case 1 :
2023-12-12 22:17:00 +00:00
/* Random Y position inside screen */
desiredY = SDLTest_RandomIntegerInRange ( display_bounds . y + 1 , display_bounds . y + 100 ) ;
break ;
2022-11-30 20:51:59 +00:00
case 2 :
2023-12-12 22:17:00 +00:00
/* Random Y position outside screen (positive) */
desiredY = SDLTest_RandomIntegerInRange ( 10000 , 11000 ) ;
break ;
2022-11-30 20:51:59 +00:00
case 3 :
2023-12-12 22:17:00 +00:00
/* Random Y position outside screen (negative) */
desiredY = SDLTest_RandomIntegerInRange ( - 1000 , - 100 ) ;
break ;
2022-11-30 20:51:59 +00:00
}
/* Set position */
SDL_SetWindowPosition ( window , desiredX , desiredY ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowPosition(...,%d,%d) " , desiredX , desiredY ) ;
/* Get position */
currentX = desiredX + 1 ;
currentY = desiredY + 1 ;
SDL_GetWindowPosition ( window , & currentX , & currentY ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowPosition() " ) ;
2023-03-25 09:24:38 +00:00
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 {
SDL_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 . */
desiredX = currentX + 1 ;
desiredY = currentY + 1 ;
hasEvent = getPositionFromEvent ( & desiredX , & desiredY ) ;
SDLTest_AssertCheck ( hasEvent = = SDL_TRUE , " Changing position was not honored by WM, checking present of SDL_WINDOWEVENT_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 ) ;
}
}
2022-11-30 20:51:59 +00:00
/* Get position X */
currentX = desiredX + 1 ;
SDL_GetWindowPosition ( window , & currentX , 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 , & currentY ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowPosition(&x=NULL) " ) ;
SDLTest_AssertCheck ( desiredY = = currentY , " Verify returned Y position; expected: %d, got: %d " , desiredY , currentY ) ;
}
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
/* Dummy call with both pointers NULL */
SDL_GetWindowPosition ( window , NULL , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowPosition(&x=NULL,&y=NULL) " ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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 , & currentX , & currentY ) ;
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 ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
SDL_GetWindowPosition ( NULL , NULL , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowPosition(NULL, NULL, NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
SDL_SetWindowPosition ( NULL , desiredX , desiredY ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowPosition(window=NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/* Helper function that checks for an 'Invalid parameter' error */
void _checkInvalidParameterError ( )
{
2022-11-30 20:51:59 +00:00
const char * invalidParameterError = " Parameter " ;
char * lastError ;
lastError = ( char * ) 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() " ) ;
}
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_GetWindowSize and SDL_SetWindowSize
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_GetWindowSize
* @ sa http : //wiki.libsdl.org/SDL_SetWindowSize
2015-06-21 15:33:46 +00:00
*/
2022-11-30 20:51:59 +00:00
int video_getSetWindowSize ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
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 ;
/* Get display bounds for size range */
2023-12-12 21:04:49 +00:00
result = SDL_GetDisplayUsableBounds ( 0 , & display ) ;
2022-11-30 20:51:59 +00:00
SDLTest_AssertPass ( " SDL_GetDisplayBounds() " ) ;
SDLTest_AssertCheck ( result = = 0 , " Verify return value; expected: 0, got: %d " , result ) ;
if ( result ! = 0 ) {
return TEST_ABORTED ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) {
2022-11-30 20:51:59 +00:00
return TEST_ABORTED ;
}
2015-06-21 15:33:46 +00:00
2023-12-12 21:04:49 +00:00
if ( SDL_strcmp ( SDL_GetCurrentVideoDriver ( ) , " windows " ) = = 0 | |
SDL_strcmp ( SDL_GetCurrentVideoDriver ( ) , " x11 " ) = = 0 ) {
2023-12-12 22:17:00 +00:00
/* Platform clips window size to screen size */
maxwVariation = 4 ;
maxhVariation = 4 ;
2023-12-12 21:04:49 +00:00
} else {
2023-12-12 22:17:00 +00:00
/* Platform allows window size >= screen size */
maxwVariation = 5 ;
maxhVariation = 5 ;
2023-12-12 21:04:49 +00:00
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
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 ) ;
/* Get size */
currentW = desiredW + 1 ;
currentH = desiredH + 1 ;
SDL_GetWindowSize ( window , & currentW , & currentH ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowSize() " ) ;
2023-03-25 09:24:38 +00:00
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 {
SDL_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 . */
desiredW = currentW + 1 ;
desiredH = currentH + 1 ;
hasEvent = getSizeFromEvent ( & desiredW , & desiredH ) ;
SDLTest_AssertCheck ( hasEvent = = SDL_TRUE , " Changing size was not honored by WM, checking presence of SDL_WINDOWEVENT_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 ) ;
}
}
2022-11-30 20:51:59 +00:00
/* Get just width */
currentW = desiredW + 1 ;
SDL_GetWindowSize ( window , & currentW , 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 , & currentH ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowSize(&w=NULL) " ) ;
SDLTest_AssertCheck ( desiredH = = currentH , " Verify returned height; expected: %d, got: %d " , desiredH , currentH ) ;
}
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
/* 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 ( ) ;
}
}
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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 , & currentW , & currentH ) ;
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 ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
SDL_GetWindowSize ( NULL , NULL , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowSize(NULL, NULL, NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
SDL_SetWindowSize ( NULL , desiredW , desiredH ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowSize(window=NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize
*
*/
2022-11-30 20:51:59 +00:00
int video_getSetWindowMinimumSize ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
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 ( 0 , & display ) ;
SDLTest_AssertPass ( " SDL_GetDisplayBounds() " ) ;
SDLTest_AssertCheck ( result = = 0 , " Verify return value; expected: 0, got: %d " , result ) ;
if ( result ! = 0 ) {
return TEST_ABORTED ;
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) {
2022-11-30 20:51:59 +00:00
return TEST_ABORTED ;
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
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 , & currentW , & currentH ) ;
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 , & currentW , 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 , & currentH ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowMinimumSize(&w=NULL) " ) ;
SDLTest_AssertCheck ( desiredH = = currentH , " Verify returned height; expected: %d, got: %d " , desiredW , currentH ) ;
}
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
/* 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 ( ) ;
}
}
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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 , & currentW , & currentH ) ;
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 ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
SDL_GetWindowMinimumSize ( NULL , NULL , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowMinimumSize(NULL, NULL, NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
SDL_SetWindowMinimumSize ( NULL , desiredW , desiredH ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowMinimumSize(window=NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize
*
*/
2022-11-30 20:51:59 +00:00
int video_getSetWindowMaximumSize ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
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 , desiredH ;
/* Get display bounds for size range */
result = SDL_GetDisplayBounds ( 0 , & display ) ;
SDLTest_AssertPass ( " SDL_GetDisplayBounds() " ) ;
SDLTest_AssertCheck ( result = = 0 , " Verify return value; expected: 0, got: %d " , result ) ;
if ( result ! = 0 ) {
return TEST_ABORTED ;
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
/* Call against new test window */
window = _createVideoSuiteTestWindow ( title ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) {
2022-11-30 20:51:59 +00:00
return TEST_ABORTED ;
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
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 , & currentW , & currentH ) ;
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 , & currentW , 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 , & currentH ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowMaximumSize(&w=NULL) " ) ;
SDLTest_AssertCheck ( desiredH = = currentH , " Verify returned height; expected: %d, got: %d " , desiredW , currentH ) ;
}
2015-06-21 15:33:46 +00:00
}
2022-11-30 20:51:59 +00:00
/* 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 ( ) ;
}
}
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* 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 , & currentW , & currentH ) ;
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 ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
SDL_GetWindowMaximumSize ( NULL , NULL , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowMaximumSize(NULL, NULL, NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
SDL_SetWindowMaximumSize ( NULL , desiredW , desiredH ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowMaximumSize(window=NULL) " ) ;
_checkInvalidWindowError ( ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
return TEST_COMPLETED ;
2015-06-21 15:33:46 +00:00
}
/**
* @ brief Tests call to SDL_SetWindowData and SDL_GetWindowData
*
2021-04-01 16:20:04 +00:00
* @ sa http : //wiki.libsdl.org/SDL_SetWindowData
* @ sa http : //wiki.libsdl.org/SDL_GetWindowData
2015-06-21 15:33:46 +00:00
*/
2022-11-30 20:51:59 +00:00
int video_getSetWindowData ( void * arg )
2015-06-21 15:33:46 +00:00
{
2022-11-30 20:51:59 +00:00
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 ) ;
2023-11-10 14:30:56 +00:00
if ( ! window ) {
2022-11-30 20:51:59 +00:00
return TEST_ABORTED ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Create testdata */
datasize = SDLTest_RandomIntegerInRange ( 1 , 32 ) ;
referenceUserdata = SDLTest_RandomAsciiStringOfSize ( datasize ) ;
2023-11-10 14:30:56 +00:00
if ( ! referenceUserdata ) {
2022-11-30 20:51:59 +00:00
returnValue = TEST_ABORTED ;
goto cleanup ;
}
userdata = SDL_strdup ( referenceUserdata ) ;
2023-11-10 14:30:56 +00:00
if ( ! userdata ) {
2022-11-30 20:51:59 +00:00
returnValue = TEST_ABORTED ;
goto cleanup ;
}
datasize = SDLTest_RandomIntegerInRange ( 1 , 32 ) ;
referenceUserdata2 = SDLTest_RandomAsciiStringOfSize ( datasize ) ;
2023-11-10 14:30:56 +00:00
if ( ! referenceUserdata2 ) {
2022-11-30 20:51:59 +00:00
returnValue = TEST_ABORTED ;
goto cleanup ;
}
2022-12-01 21:07:03 +00:00
userdata2 = SDL_strdup ( referenceUserdata2 ) ;
2023-11-10 14:30:56 +00:00
if ( ! userdata2 ) {
2022-11-30 20:51:59 +00:00
returnValue = TEST_ABORTED ;
goto cleanup ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get non-existent data */
result = ( char * ) SDL_GetWindowData ( window , name ) ;
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 */
result = ( char * ) SDL_SetWindowData ( window , name , userdata ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(...%s,%s) " , name , userdata ) ;
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 ) ;
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_GetWindowData ( window , name ) ;
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 + + ) {
result = ( char * ) SDL_SetWindowData ( window , name , userdata ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(...%s,%s) [iteration %d] " , name , userdata , 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 ) ;
SDLTest_AssertCheck ( SDL_strcmp ( referenceUserdata , userdata ) = = 0 , " Validate that userdata was not changed, expected: %s, got: %s " , referenceUserdata , userdata ) ;
}
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get data again */
2015-06-21 15:33:46 +00:00
result = ( char * ) SDL_GetWindowData ( window , name ) ;
2022-11-30 20:51:59 +00:00
SDLTest_AssertPass ( " Call to SDL_GetWindowData(..,%s) [again] " , name ) ;
2015-06-21 15:33:46 +00:00
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 ) ;
2022-11-30 20:51:59 +00:00
/* Set data with new data */
result = ( char * ) SDL_SetWindowData ( window , name , userdata2 ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(...%s,%s) [new userdata] " , name , userdata2 ) ;
2015-06-21 15:33:46 +00:00
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 ) ;
SDLTest_AssertCheck ( SDL_strcmp ( referenceUserdata , userdata ) = = 0 , " Validate that userdata was not changed, expected: %s, got: %s " , referenceUserdata , userdata ) ;
2022-11-30 20:51:59 +00:00
SDLTest_AssertCheck ( SDL_strcmp ( referenceUserdata2 , userdata2 ) = = 0 , " Validate that userdata2 was not changed, expected: %s, got: %s " , referenceUserdata2 , userdata2 ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Set data with new data again */
result = ( char * ) SDL_SetWindowData ( window , name , userdata2 ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(...%s,%s) [new userdata again] " , name , userdata2 ) ;
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 ) ;
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 ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get new data */
result = ( char * ) SDL_GetWindowData ( window , name ) ;
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 ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Set data with NULL to clear */
result = ( char * ) SDL_SetWindowData ( window , name , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(...%s,NULL) " , 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 ) ;
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 ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Set data with NULL to clear again */
result = ( char * ) SDL_SetWindowData ( window , name , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(...%s,NULL) [again] " , 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 ) ;
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 ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get non-existent data */
result = ( char * ) SDL_GetWindowData ( window , name ) ;
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 ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get non-existent data new name */
result = ( char * ) SDL_GetWindowData ( window , name2 ) ;
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 ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Set data (again) */
result = ( char * ) SDL_SetWindowData ( window , name , userdata ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(...%s,%s) [again, after clear] " , name , userdata ) ;
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 ) ;
SDLTest_AssertCheck ( SDL_strcmp ( referenceUserdata , userdata ) = = 0 , " Validate that userdata was not changed, expected: %s, got: %s " , referenceUserdata , userdata ) ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
/* Get data (again) */
result = ( char * ) SDL_GetWindowData ( window , name ) ;
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 ) ;
/* Negative test */
SDL_ClearError ( ) ;
SDLTest_AssertPass ( " Call to SDL_ClearError() " ) ;
/* Set with invalid window */
result = ( char * ) SDL_SetWindowData ( NULL , name , userdata ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(window=NULL) " ) ;
SDLTest_AssertCheck ( result = = NULL , " Validate that result is NULL " ) ;
_checkInvalidWindowError ( ) ;
/* Set data with NULL name, valid userdata */
result = ( char * ) SDL_SetWindowData ( window , NULL , userdata ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(name=NULL) " ) ;
SDLTest_AssertCheck ( result = = NULL , " Validate that result is NULL " ) ;
_checkInvalidParameterError ( ) ;
/* Set data with empty name, valid userdata */
result = ( char * ) SDL_SetWindowData ( window , " " , userdata ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(name='') " ) ;
SDLTest_AssertCheck ( result = = NULL , " Validate that result is NULL " ) ;
_checkInvalidParameterError ( ) ;
/* Set data with NULL name, NULL userdata */
result = ( char * ) SDL_SetWindowData ( window , NULL , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(name=NULL,userdata=NULL) " ) ;
SDLTest_AssertCheck ( result = = NULL , " Validate that result is NULL " ) ;
_checkInvalidParameterError ( ) ;
/* Set data with empty name, NULL userdata */
result = ( char * ) SDL_SetWindowData ( window , " " , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_SetWindowData(name='',userdata=NULL) " ) ;
SDLTest_AssertCheck ( result = = NULL , " Validate that result is NULL " ) ;
_checkInvalidParameterError ( ) ;
/* Get with invalid window */
result = ( char * ) SDL_GetWindowData ( NULL , name ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowData(window=NULL) " ) ;
SDLTest_AssertCheck ( result = = NULL , " Validate that result is NULL " ) ;
_checkInvalidWindowError ( ) ;
/* Get data with NULL name */
result = ( char * ) SDL_GetWindowData ( window , NULL ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowData(name=NULL) " ) ;
SDLTest_AssertCheck ( result = = NULL , " Validate that result is NULL " ) ;
_checkInvalidParameterError ( ) ;
/* Get data with empty name */
result = ( char * ) SDL_GetWindowData ( window , " " ) ;
SDLTest_AssertPass ( " Call to SDL_GetWindowData(name='') " ) ;
SDLTest_AssertCheck ( result = = NULL , " Validate that result is NULL " ) ;
_checkInvalidParameterError ( ) ;
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
cleanup :
SDL_free ( referenceUserdata ) ;
SDL_free ( referenceUserdata2 ) ;
SDL_free ( userdata ) ;
SDL_free ( userdata2 ) ;
return returnValue ;
2015-06-21 15:33:46 +00:00
}
2022-06-05 20:44:30 +00:00
/**
2022-11-30 20:51:59 +00:00
* @ brief Tests the functionality of the SDL_WINDOWPOS_CENTERED_DISPLAY along with SDL_WINDOW_FULLSCREEN_DESKTOP .
*
* Espeically 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 .
*/
int video_setWindowCenteredOnDisplay ( void * arg )
2022-06-05 20:44:30 +00:00
{
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 ;
displayNum = SDL_GetNumVideoDisplays ( ) ;
2023-10-14 01:23:33 +00:00
SDLTest_AssertPass ( " SDL_GetNumVideoDisplays() " ) ;
SDLTest_AssertCheck ( displayNum > = 1 , " Validate result (current: %d, expected >= 1) " , displayNum ) ;
if ( displayNum < = 0 ) {
return TEST_ABORTED ;
}
2022-06-05 20:44:30 +00:00
/* Get display bounds */
result = SDL_GetDisplayBounds ( 0 % displayNum , & display0 ) ;
SDLTest_AssertPass ( " SDL_GetDisplayBounds() " ) ;
SDLTest_AssertCheck ( result = = 0 , " Verify return value; expected: 0, got: %d " , result ) ;
2022-11-27 16:38:43 +00:00
if ( result ! = 0 ) {
2022-06-05 20:44:30 +00:00
return TEST_ABORTED ;
2022-11-27 16:38:43 +00:00
}
2022-06-05 20:44:30 +00:00
result = SDL_GetDisplayBounds ( 1 % displayNum , & display1 ) ;
SDLTest_AssertPass ( " SDL_GetDisplayBounds() " ) ;
SDLTest_AssertCheck ( result = = 0 , " Verify return value; expected: 0, got: %d " , result ) ;
2022-11-27 16:38:43 +00:00
if ( result ! = 0 ) {
2022-06-05 20:44:30 +00:00
return TEST_ABORTED ;
2022-11-27 16:38:43 +00:00
}
2022-06-05 20:44:30 +00:00
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 ;
2023-10-06 17:50:10 +00:00
SDL_bool video_driver_is_wayland = SDL_strcmp ( SDL_GetCurrentVideoDriver ( ) , " wayland " ) = = 0 ;
2022-06-05 20:44:30 +00:00
/* xVariation is the display we start on */
expectedDisplay = 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 ) ) ;
2023-12-12 21:04:49 +00:00
window = SDL_CreateWindow ( title , x , y , w , h , SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_BORDERLESS ) ;
2022-06-05 20:44:30 +00:00
SDLTest_AssertPass ( " Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN) " , x , y , w , h ) ;
SDLTest_AssertCheck ( window ! = NULL , " Validate that returned window struct is not NULL " ) ;
2023-10-06 17:50:10 +00:00
/* 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 , - 1 , 0 ) ;
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 " ) ;
}
}
2022-06-05 20:44:30 +00:00
/* Check the window is centered on the requested display */
currentDisplay = SDL_GetWindowDisplayIndex ( window ) ;
SDL_GetWindowSize ( window , & currentW , & currentH ) ;
SDL_GetWindowPosition ( window , & currentX , & currentY ) ;
2023-10-06 17:50:10 +00:00
if ( ! video_driver_is_wayland ) {
SDLTest_AssertCheck ( currentDisplay = = expectedDisplay , " Validate display index (current: %d, expected: %d) " , currentDisplay , expectedDisplay ) ;
} else {
SDLTest_Log ( " Skipping display index validation: Wayland driver does not support window positioning " ) ;
}
2022-06-05 20:44:30 +00:00
SDLTest_AssertCheck ( currentW = = w , " Validate width (current: %d, expected: %d) " , currentW , w ) ;
SDLTest_AssertCheck ( currentH = = h , " Validate height (current: %d, expected: %d) " , currentH , h ) ;
2023-10-06 17:50:10 +00:00
if ( ! video_driver_is_wayland ) {
SDLTest_AssertCheck ( currentX = = expectedX , " Validate x (current: %d, expected: %d) " , currentX , expectedX ) ;
SDLTest_AssertCheck ( currentY = = expectedY , " Validate y (current: %d, expected: %d) " , currentY , expectedY ) ;
} else {
SDLTest_Log ( " Skipping window position validation: Wayland driver does not support window positioning " ) ;
}
2022-06-05 20:44:30 +00:00
/* Enter fullscreen desktop */
result = SDL_SetWindowFullscreen ( window , SDL_WINDOW_FULLSCREEN_DESKTOP ) ;
SDLTest_AssertCheck ( result = = 0 , " Verify return value; expected: 0, got: %d " , result ) ;
/* Check we are filling the full display */
currentDisplay = SDL_GetWindowDisplayIndex ( window ) ;
SDL_GetWindowSize ( window , & currentW , & currentH ) ;
SDL_GetWindowPosition ( window , & currentX , & currentY ) ;
2023-10-06 17:50:10 +00:00
if ( ! video_driver_is_wayland ) {
SDLTest_AssertCheck ( currentDisplay = = expectedDisplay , " Validate display index (current: %d, expected: %d) " , currentDisplay , expectedDisplay ) ;
} else {
SDLTest_Log ( " Skipping display index validation: Wayland driver does not support window positioning " ) ;
}
2022-06-05 20:44:30 +00:00
SDLTest_AssertCheck ( currentW = = expectedDisplayRect . w , " Validate width (current: %d, expected: %d) " , currentW , expectedDisplayRect . w ) ;
SDLTest_AssertCheck ( currentH = = expectedDisplayRect . h , " Validate height (current: %d, expected: %d) " , currentH , expectedDisplayRect . h ) ;
2023-10-06 17:50:10 +00:00
if ( ! video_driver_is_wayland ) {
SDLTest_AssertCheck ( currentX = = expectedDisplayRect . x , " Validate x (current: %d, expected: %d) " , currentX , expectedDisplayRect . x ) ;
SDLTest_AssertCheck ( currentY = = expectedDisplayRect . y , " Validate y (current: %d, expected: %d) " , currentY , expectedDisplayRect . y ) ;
} else {
SDLTest_Log ( " Skipping window position validation: Wayland driver does not support window positioning " ) ;
}
2022-06-05 20:44:30 +00:00
/* Leave fullscreen desktop */
result = SDL_SetWindowFullscreen ( window , 0 ) ;
SDLTest_AssertCheck ( result = = 0 , " Verify return value; expected: 0, got: %d " , result ) ;
/* Check window was restored correctly */
currentDisplay = SDL_GetWindowDisplayIndex ( window ) ;
SDL_GetWindowSize ( window , & currentW , & currentH ) ;
SDL_GetWindowPosition ( window , & currentX , & currentY ) ;
2023-10-06 17:50:10 +00:00
if ( ! video_driver_is_wayland ) {
SDLTest_AssertCheck ( currentDisplay = = expectedDisplay , " Validate display index (current: %d, expected: %d) " , currentDisplay , expectedDisplay ) ;
} else {
SDLTest_Log ( " Skipping display index validation: Wayland driver does not support window positioning " ) ;
}
2022-06-05 20:44:30 +00:00
SDLTest_AssertCheck ( currentW = = w , " Validate width (current: %d, expected: %d) " , currentW , w ) ;
SDLTest_AssertCheck ( currentH = = h , " Validate height (current: %d, expected: %d) " , currentH , h ) ;
2023-10-06 17:50:10 +00:00
if ( ! video_driver_is_wayland ) {
SDLTest_AssertCheck ( currentX = = expectedX , " Validate x (current: %d, expected: %d) " , currentX , expectedX ) ;
SDLTest_AssertCheck ( currentY = = expectedY , " Validate y (current: %d, expected: %d) " , currentY , expectedY ) ;
} else {
SDLTest_Log ( " Skipping window position validation: Wayland driver does not support window positioning " ) ;
}
2022-06-05 20:44:30 +00:00
/* Center on display yVariation, and check window properties */
expectedDisplay = yVariation % displayNum ;
x = SDL_WINDOWPOS_CENTERED_DISPLAY ( expectedDisplay ) ;
y = SDL_WINDOWPOS_CENTERED_DISPLAY ( expectedDisplay ) ;
expectedDisplayRect = ( expectedDisplay = = 0 ) ? display0 : display1 ;
expectedX = ( expectedDisplayRect . x + ( ( expectedDisplayRect . w - w ) / 2 ) ) ;
expectedY = ( expectedDisplayRect . y + ( ( expectedDisplayRect . h - h ) / 2 ) ) ;
SDL_SetWindowPosition ( window , x , y ) ;
currentDisplay = SDL_GetWindowDisplayIndex ( window ) ;
SDL_GetWindowSize ( window , & currentW , & currentH ) ;
SDL_GetWindowPosition ( window , & currentX , & currentY ) ;
2023-10-06 17:50:10 +00:00
if ( ! video_driver_is_wayland ) {
SDLTest_AssertCheck ( currentDisplay = = expectedDisplay , " Validate display index (current: %d, expected: %d) " , currentDisplay , expectedDisplay ) ;
} else {
SDLTest_Log ( " Skipping display index validation: Wayland driver does not support window positioning " ) ;
}
2022-06-05 20:44:30 +00:00
SDLTest_AssertCheck ( currentW = = w , " Validate width (current: %d, expected: %d) " , currentW , w ) ;
SDLTest_AssertCheck ( currentH = = h , " Validate height (current: %d, expected: %d) " , currentH , h ) ;
2023-10-06 17:50:10 +00:00
if ( ! video_driver_is_wayland ) {
SDLTest_AssertCheck ( currentX = = expectedX , " Validate x (current: %d, expected: %d) " , currentX , expectedX ) ;
SDLTest_AssertCheck ( currentY = = expectedY , " Validate y (current: %d, expected: %d) " , currentY , expectedY ) ;
} else {
SDLTest_Log ( " Skipping window position validation: Wayland driver does not support window positioning " ) ;
}
2022-06-05 20:44:30 +00:00
/* Clean up */
_destroyVideoSuiteTestWindow ( window ) ;
}
}
return TEST_COMPLETED ;
}
2015-06-21 15:33:46 +00:00
/* ================= Test References ================== */
/* Video test cases */
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest1 = {
( SDLTest_TestCaseFp ) video_enableDisableScreensaver , " video_enableDisableScreensaver " , " Enable and disable screenaver while checking state " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest2 = {
( SDLTest_TestCaseFp ) video_createWindowVariousPositions , " video_createWindowVariousPositions " , " Create windows at various locations " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest3 = {
( SDLTest_TestCaseFp ) video_createWindowVariousSizes , " video_createWindowVariousSizes " , " Create windows with various sizes " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest4 = {
( SDLTest_TestCaseFp ) video_createWindowVariousFlags , " video_createWindowVariousFlags " , " Create windows using various flags " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest5 = {
( SDLTest_TestCaseFp ) video_getWindowFlags , " video_getWindowFlags " , " Get window flags set during SDL_CreateWindow " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest6 = {
( SDLTest_TestCaseFp ) video_getNumDisplayModes , " video_getNumDisplayModes " , " Use SDL_GetNumDisplayModes function to get number of display modes " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest7 = {
( SDLTest_TestCaseFp ) video_getNumDisplayModesNegative , " video_getNumDisplayModesNegative " , " Negative tests for SDL_GetNumDisplayModes " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest8 = {
( SDLTest_TestCaseFp ) video_getClosestDisplayModeCurrentResolution , " video_getClosestDisplayModeCurrentResolution " , " Use function to get closes match to requested display mode for current resolution " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference videoTest9 = {
( SDLTest_TestCaseFp ) video_getClosestDisplayModeRandomResolution , " video_getClosestDisplayModeRandomResolution " , " Use function to get closes match to requested display mode for random resolution " , TEST_ENABLED
} ;
2015-06-21 15:33:46 +00:00
static const SDLTest_TestCaseReference videoTest10 =
{ ( SDLTest_TestCaseFp ) video_getWindowBrightness , " video_getWindowBrightness " , " Get window brightness " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest11 =
{ ( SDLTest_TestCaseFp ) video_getWindowBrightnessNegative , " video_getWindowBrightnessNegative " , " Get window brightness with invalid input " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest12 =
{ ( SDLTest_TestCaseFp ) video_getWindowDisplayMode , " video_getWindowDisplayMode " , " Get window display mode " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest13 =
{ ( SDLTest_TestCaseFp ) video_getWindowDisplayModeNegative , " video_getWindowDisplayModeNegative " , " Get window display mode with invalid input " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest14 =
{ ( SDLTest_TestCaseFp ) video_getWindowGammaRamp , " video_getWindowGammaRamp " , " Get window gamma ramp " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest15 =
{ ( SDLTest_TestCaseFp ) video_getWindowGammaRampNegative , " video_getWindowGammaRampNegative " , " Get window gamma ramp against invalid input " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest16 =
{ ( SDLTest_TestCaseFp ) video_getSetWindowGrab , " video_getSetWindowGrab " , " Checks SDL_GetWindowGrab and SDL_SetWindowGrab positive and negative cases " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest17 =
{ ( SDLTest_TestCaseFp ) video_getWindowId , " video_getWindowId " , " Checks SDL_GetWindowID and SDL_GetWindowFromID " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest18 =
{ ( SDLTest_TestCaseFp ) video_getWindowPixelFormat , " video_getWindowPixelFormat " , " Checks SDL_GetWindowPixelFormat " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest19 =
{ ( SDLTest_TestCaseFp ) video_getSetWindowPosition , " video_getSetWindowPosition " , " Checks SDL_GetWindowPosition and SDL_SetWindowPosition positive and negative cases " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest20 =
{ ( SDLTest_TestCaseFp ) video_getSetWindowSize , " video_getSetWindowSize " , " Checks SDL_GetWindowSize and SDL_SetWindowSize positive and negative cases " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest21 =
{ ( SDLTest_TestCaseFp ) video_getSetWindowMinimumSize , " video_getSetWindowMinimumSize " , " Checks SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize positive and negative cases " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest22 =
{ ( SDLTest_TestCaseFp ) video_getSetWindowMaximumSize , " video_getSetWindowMaximumSize " , " Checks SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize positive and negative cases " , TEST_ENABLED } ;
static const SDLTest_TestCaseReference videoTest23 =
{ ( SDLTest_TestCaseFp ) video_getSetWindowData , " video_getSetWindowData " , " Checks SDL_SetWindowData and SDL_GetWindowData positive and negative cases " , TEST_ENABLED } ;
2022-06-05 20:44:30 +00:00
static const SDLTest_TestCaseReference videoTest24 =
{ ( SDLTest_TestCaseFp ) video_setWindowCenteredOnDisplay , " video_setWindowCenteredOnDisplay " , " Checks using SDL_WINDOWPOS_CENTERED_DISPLAY centers the window on a display " , TEST_ENABLED } ;
2015-06-21 15:33:46 +00:00
/* Sequence of Video test cases */
2022-11-30 20:51:59 +00:00
static const SDLTest_TestCaseReference * videoTests [ ] = {
2015-06-21 15:33:46 +00:00
& videoTest1 , & videoTest2 , & videoTest3 , & videoTest4 , & videoTest5 , & videoTest6 ,
& videoTest7 , & videoTest8 , & videoTest9 , & videoTest10 , & videoTest11 , & videoTest12 ,
& videoTest13 , & videoTest14 , & videoTest15 , & videoTest16 , & videoTest17 ,
& videoTest18 , & videoTest19 , & videoTest20 , & videoTest21 , & videoTest22 ,
2022-06-05 20:44:30 +00:00
& videoTest23 , & videoTest24 , NULL
2015-06-21 15:33:46 +00:00
} ;
/* Video test suite (global) */
SDLTest_TestSuiteReference videoTestSuite = {
" Video " ,
NULL ,
videoTests ,
NULL
} ;